// Generated from RubyParser.g4 by ANTLR 4.12.0
package com.codeanalysissys.backend.ruby.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class RubyParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		HereDoc1=1, HereDoc2=2, HereDoc3=3, PercentString=4, SYNTAXERROR=5, PUBLIC=6, 
		PROTECTED=7, PRIVATE=8, INCLUDE=9, PRINT=10, PUTS=11, PRINTF=12, P=13, 
		LOAD=14, REQUIRE=15, REQUIRE_RELATIVE=16, ALIAS=17, BEGIN=18, BEGIN_BLOCK=19, 
		BREAK=20, CASE=21, CLASS=22, DEF=23, DEFINED=24, DO=25, ELSE=26, ELSIF=27, 
		END_BLOCK=28, END=29, ENSURE=30, FALSE=31, FOR=32, IF=33, IN=34, MODULE=35, 
		NEXT=36, NIL=37, NOT=38, RAISE=39, REDO=40, RESCUE=41, RETRY=42, RETURN=43, 
		SELF=44, SUPER=45, THEN=46, TRUE=47, UNDEF=48, UNLESS=49, UNTIL=50, WHEN=51, 
		WHILE=52, YIELD=53, Integer=54, Float=55, Regex=56, String=57, DollarSpecial=58, 
		CRLF=59, AND=60, OR=61, PLUS=62, MINUS=63, MOD=64, PLUS_ASSIGN=65, MOD_ASSIGN=66, 
		SHARP=67, AND_ASSIGN=68, BIT_AND_ASSIGN=69, ANDDOT=70, BIT_AND=71, EXP_ASSIGN=72, 
		EXP=73, MUL=74, MUL_ASSIGN=75, DOLLAR=76, AT=77, RIGHT_PAREN=78, LEFT_PAREN=79, 
		RIGHT_SBRACKET=80, LEFT_SBRACKET=81, RIGHT_RBRACKET=82, LEFT_RBRACKET=83, 
		DOT3=84, DOT2=85, DOT=86, DIV_ASSIGN=87, DIV=88, QUESTION=89, NOT_EQUAL=90, 
		SIGH=91, COLON=92, COLON2=93, SEMICOLON=94, COMMA=95, MINUS_ASSIGN=96, 
		OR_ASSIGN=97, BIT_OR_ASSIGN=98, BIT_OR=99, BIT_SHR_ASSIGN=100, GREATER_EQUAL=101, 
		BIT_SHR=102, GREATER=103, ASSIGN=104, ASSOC=105, EQUAL3=106, EQUAL=107, 
		PATTERN_MATCH=108, LESS_EQUAL=109, LESS=110, BIT_SHL_ASSIGN=111, BIT_SHL=112, 
		BIT_NOT_ASSIGN=113, BIT_NOT=114, BIT_XOR_ASSIGN=115, BIT_XOR=116, SL_COMMENT=117, 
		ML_COMMENT=118, WS=119, Identifier=120, ShellCommand=121, HereDocEnd1=122, 
		HereDocEnd2=123, AnyInHere=124, SL_COMMENT_IN_HEREDOC=125, ML_COMMENT_IN_HEREDOC=126, 
		PercentStringLineEnd=127, AnyInQuotedString1=128, AnyInQuotedString2=129, 
		Digits=130, ExponentPart=131, NumberTypeSuffix=132;
	public static final int
		RULE_compilation_unit = 0, RULE_statement_list_terms = 1, RULE_statement_list_noterms = 2, 
		RULE_statement = 3, RULE_undef_statement = 4, RULE_alias_statement = 5, 
		RULE_function_name_or_symbol = 6, RULE_imports = 7, RULE_begin_block = 8, 
		RULE_end_block = 9, RULE_module_definition = 10, RULE_class_definition = 11, 
		RULE_superclass = 12, RULE_class_header = 13, RULE_function_definition = 14, 
		RULE_function_definition_header = 15, RULE_function_name = 16, RULE_function_definition_params = 17, 
		RULE_function_definition_param = 18, RULE_function_call_param = 19, RULE_expr = 20, 
		RULE_expr_statement_suffix = 21, RULE_primary = 22, RULE_func_call_parameters = 23, 
		RULE_func_call_parameters_no_bracket = 24, RULE_rescure_param = 25, RULE_case_body = 26, 
		RULE_when_cond = 27, RULE_if_tail = 28, RULE_else_tail = 29, RULE_dot_ref = 30, 
		RULE_logicalOperator = 31, RULE_equalsOperator = 32, RULE_compareOperator = 33, 
		RULE_bitOperator = 34, RULE_mathOperator = 35, RULE_assignOperator = 36, 
		RULE_not = 37, RULE_block = 38, RULE_block_params = 39, RULE_id_symbol = 40, 
		RULE_symbol = 41, RULE_hash_asso = 42, RULE_variable_path = 43, RULE_cpath = 44, 
		RULE_literal = 45, RULE_identifier = 46, RULE_next = 47, RULE_empty = 48, 
		RULE_globalVar = 49, RULE_classVar = 50, RULE_instanceVar = 51, RULE_idArg = 52, 
		RULE_do_keyword = 53, RULE_then_keyword = 54, RULE_string = 55, RULE_ensure = 56, 
		RULE_crlfs = 57, RULE_terms = 58, RULE_term = 59, RULE_rescuestatement = 60, 
		RULE_print = 61, RULE_inclu = 62, RULE_modifier = 63, RULE_syntaxError = 64, 
		RULE_retry = 65;
	private static String[] makeRuleNames() {
		return new String[] {
			"compilation_unit", "statement_list_terms", "statement_list_noterms", 
			"statement", "undef_statement", "alias_statement", "function_name_or_symbol", 
			"imports", "begin_block", "end_block", "module_definition", "class_definition", 
			"superclass", "class_header", "function_definition", "function_definition_header", 
			"function_name", "function_definition_params", "function_definition_param", 
			"function_call_param", "expr", "expr_statement_suffix", "primary", "func_call_parameters", 
			"func_call_parameters_no_bracket", "rescure_param", "case_body", "when_cond", 
			"if_tail", "else_tail", "dot_ref", "logicalOperator", "equalsOperator", 
			"compareOperator", "bitOperator", "mathOperator", "assignOperator", "not", 
			"block", "block_params", "id_symbol", "symbol", "hash_asso", "variable_path", 
			"cpath", "literal", "identifier", "next", "empty", "globalVar", "classVar", 
			"instanceVar", "idArg", "do_keyword", "then_keyword", "string", "ensure", 
			"crlfs", "terms", "term", "rescuestatement", "print", "inclu", "modifier", 
			"syntaxError", "retry"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, null, null, null, "'SyntaxError'", "'public'", "'protected'", 
			"'private'", "'include'", "'print'", "'puts'", "'printf'", "'p'", "'load'", 
			"'require'", "'require_relative'", "'alias'", "'begin'", "'BEGIN'", "'break'", 
			"'case'", "'class'", "'def'", "'defined?'", "'do'", "'else'", "'elsif'", 
			"'END'", "'end'", "'ensure'", "'false'", "'for'", "'if'", "'in'", "'module'", 
			"'next'", "'nil'", "'not'", "'raise'", "'redo'", "'rescue'", "'retry'", 
			"'return'", "'self'", "'super'", "'then'", "'true'", "'undef'", "'unless'", 
			"'until'", "'when'", "'while'", "'yield'", null, null, null, null, null, 
			null, null, null, "'+'", "'-'", "'%'", "'+='", "'%='", "'#'", "'&&='", 
			"'&='", "'&.'", "'&'", "'**='", "'**'", "'*'", "'*='", "'$'", "'@'", 
			"'}'", "'{'", "']'", "'['", "')'", "'('", "'...'", "'..'", "'.'", "'/='", 
			"'/'", "'?'", "'!='", "'!'", "':'", "'::'", "';'", "','", "'-='", "'||='", 
			"'|='", "'|'", "'>>='", "'>='", "'>>'", "'>'", "'='", "'=>'", "'==='", 
			"'=='", "'=~'", "'<='", "'<'", "'<<='", "'<<'", "'~='", "'~'", "'^='", 
			"'^'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "HereDoc1", "HereDoc2", "HereDoc3", "PercentString", "SYNTAXERROR", 
			"PUBLIC", "PROTECTED", "PRIVATE", "INCLUDE", "PRINT", "PUTS", "PRINTF", 
			"P", "LOAD", "REQUIRE", "REQUIRE_RELATIVE", "ALIAS", "BEGIN", "BEGIN_BLOCK", 
			"BREAK", "CASE", "CLASS", "DEF", "DEFINED", "DO", "ELSE", "ELSIF", "END_BLOCK", 
			"END", "ENSURE", "FALSE", "FOR", "IF", "IN", "MODULE", "NEXT", "NIL", 
			"NOT", "RAISE", "REDO", "RESCUE", "RETRY", "RETURN", "SELF", "SUPER", 
			"THEN", "TRUE", "UNDEF", "UNLESS", "UNTIL", "WHEN", "WHILE", "YIELD", 
			"Integer", "Float", "Regex", "String", "DollarSpecial", "CRLF", "AND", 
			"OR", "PLUS", "MINUS", "MOD", "PLUS_ASSIGN", "MOD_ASSIGN", "SHARP", "AND_ASSIGN", 
			"BIT_AND_ASSIGN", "ANDDOT", "BIT_AND", "EXP_ASSIGN", "EXP", "MUL", "MUL_ASSIGN", 
			"DOLLAR", "AT", "RIGHT_PAREN", "LEFT_PAREN", "RIGHT_SBRACKET", "LEFT_SBRACKET", 
			"RIGHT_RBRACKET", "LEFT_RBRACKET", "DOT3", "DOT2", "DOT", "DIV_ASSIGN", 
			"DIV", "QUESTION", "NOT_EQUAL", "SIGH", "COLON", "COLON2", "SEMICOLON", 
			"COMMA", "MINUS_ASSIGN", "OR_ASSIGN", "BIT_OR_ASSIGN", "BIT_OR", "BIT_SHR_ASSIGN", 
			"GREATER_EQUAL", "BIT_SHR", "GREATER", "ASSIGN", "ASSOC", "EQUAL3", "EQUAL", 
			"PATTERN_MATCH", "LESS_EQUAL", "LESS", "BIT_SHL_ASSIGN", "BIT_SHL", "BIT_NOT_ASSIGN", 
			"BIT_NOT", "BIT_XOR_ASSIGN", "BIT_XOR", "SL_COMMENT", "ML_COMMENT", "WS", 
			"Identifier", "ShellCommand", "HereDocEnd1", "HereDocEnd2", "AnyInHere", 
			"SL_COMMENT_IN_HEREDOC", "ML_COMMENT_IN_HEREDOC", "PercentStringLineEnd", 
			"AnyInQuotedString1", "AnyInQuotedString2", "Digits", "ExponentPart", 
			"NumberTypeSuffix"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "RubyParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public RubyParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Compilation_unitContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(RubyParser.EOF, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Compilation_unitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compilation_unit; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitCompilation_unit(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Compilation_unitContext compilation_unit() throws RecognitionException {
		Compilation_unitContext _localctx = new Compilation_unitContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_compilation_unit);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(133);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				{
				setState(132);
				statement_list_terms(0);
				}
				break;
			}
			setState(135);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Statement_list_termsContext extends ParserRuleContext {
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Statement_list_termsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement_list_terms; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitStatement_list_terms(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Statement_list_termsContext statement_list_terms() throws RecognitionException {
		return statement_list_terms(0);
	}

	private Statement_list_termsContext statement_list_terms(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Statement_list_termsContext _localctx = new Statement_list_termsContext(_ctx, _parentState);
		Statement_list_termsContext _prevctx = _localctx;
		int _startState = 2;
		enterRecursionRule(_localctx, 2, RULE_statement_list_terms, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(142);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				{
				setState(138);
				statement();
				setState(139);
				terms();
				}
				break;
			case 2:
				{
				setState(141);
				terms();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(150);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new Statement_list_termsContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_statement_list_terms);
					setState(144);
					if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
					setState(145);
					statement();
					setState(146);
					terms();
					}
					} 
				}
				setState(152);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Statement_list_notermsContext extends ParserRuleContext {
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public List<TermsContext> terms() {
			return getRuleContexts(TermsContext.class);
		}
		public TermsContext terms(int i) {
			return getRuleContext(TermsContext.class,i);
		}
		public Statement_list_notermsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement_list_noterms; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitStatement_list_noterms(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Statement_list_notermsContext statement_list_noterms() throws RecognitionException {
		Statement_list_notermsContext _localctx = new Statement_list_notermsContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_statement_list_noterms);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(158);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(153);
					statement();
					setState(154);
					terms();
					}
					} 
				}
				setState(160);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			}
			setState(161);
			statement();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StatementContext extends ParserRuleContext {
		public ImportsContext imports() {
			return getRuleContext(ImportsContext.class,0);
		}
		public Begin_blockContext begin_block() {
			return getRuleContext(Begin_blockContext.class,0);
		}
		public End_blockContext end_block() {
			return getRuleContext(End_blockContext.class,0);
		}
		public Alias_statementContext alias_statement() {
			return getRuleContext(Alias_statementContext.class,0);
		}
		public Undef_statementContext undef_statement() {
			return getRuleContext(Undef_statementContext.class,0);
		}
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_statement);
		try {
			setState(169);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LOAD:
			case REQUIRE:
			case REQUIRE_RELATIVE:
				enterOuterAlt(_localctx, 1);
				{
				setState(163);
				imports();
				}
				break;
			case BEGIN_BLOCK:
				enterOuterAlt(_localctx, 2);
				{
				setState(164);
				begin_block();
				}
				break;
			case END_BLOCK:
				enterOuterAlt(_localctx, 3);
				{
				setState(165);
				end_block();
				}
				break;
			case ALIAS:
				enterOuterAlt(_localctx, 4);
				{
				setState(166);
				alias_statement();
				}
				break;
			case UNDEF:
				enterOuterAlt(_localctx, 5);
				{
				setState(167);
				undef_statement();
				}
				break;
			case SYNTAXERROR:
			case PUBLIC:
			case PROTECTED:
			case PRIVATE:
			case INCLUDE:
			case PRINT:
			case PUTS:
			case PRINTF:
			case P:
			case BEGIN:
			case BREAK:
			case CASE:
			case CLASS:
			case DEF:
			case DEFINED:
			case FALSE:
			case FOR:
			case IF:
			case MODULE:
			case NEXT:
			case NIL:
			case NOT:
			case RAISE:
			case REDO:
			case RETRY:
			case RETURN:
			case SELF:
			case SUPER:
			case TRUE:
			case UNLESS:
			case UNTIL:
			case WHEN:
			case WHILE:
			case YIELD:
			case Integer:
			case Float:
			case Regex:
			case String:
			case DollarSpecial:
			case AND:
			case OR:
			case PLUS:
			case MINUS:
			case MOD:
			case PLUS_ASSIGN:
			case MOD_ASSIGN:
			case AND_ASSIGN:
			case BIT_AND_ASSIGN:
			case BIT_AND:
			case EXP_ASSIGN:
			case EXP:
			case MUL:
			case MUL_ASSIGN:
			case DOLLAR:
			case AT:
			case LEFT_PAREN:
			case LEFT_SBRACKET:
			case LEFT_RBRACKET:
			case DIV_ASSIGN:
			case DIV:
			case NOT_EQUAL:
			case SIGH:
			case COLON:
			case COLON2:
			case MINUS_ASSIGN:
			case OR_ASSIGN:
			case BIT_OR_ASSIGN:
			case BIT_OR:
			case BIT_SHR_ASSIGN:
			case GREATER_EQUAL:
			case BIT_SHR:
			case GREATER:
			case EQUAL3:
			case EQUAL:
			case LESS_EQUAL:
			case LESS:
			case BIT_SHL_ASSIGN:
			case BIT_SHL:
			case BIT_NOT_ASSIGN:
			case BIT_NOT:
			case BIT_XOR_ASSIGN:
			case BIT_XOR:
			case Identifier:
			case ShellCommand:
				enterOuterAlt(_localctx, 6);
				{
				setState(168);
				expr(0);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Undef_statementContext extends ParserRuleContext {
		public TerminalNode UNDEF() { return getToken(RubyParser.UNDEF, 0); }
		public List<Function_name_or_symbolContext> function_name_or_symbol() {
			return getRuleContexts(Function_name_or_symbolContext.class);
		}
		public Function_name_or_symbolContext function_name_or_symbol(int i) {
			return getRuleContext(Function_name_or_symbolContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public Undef_statementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_undef_statement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitUndef_statement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Undef_statementContext undef_statement() throws RecognitionException {
		Undef_statementContext _localctx = new Undef_statementContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_undef_statement);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(171);
			match(UNDEF);
			setState(172);
			function_name_or_symbol();
			setState(177);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(173);
					match(COMMA);
					setState(174);
					function_name_or_symbol();
					}
					} 
				}
				setState(179);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Alias_statementContext extends ParserRuleContext {
		public TerminalNode ALIAS() { return getToken(RubyParser.ALIAS, 0); }
		public List<Function_name_or_symbolContext> function_name_or_symbol() {
			return getRuleContexts(Function_name_or_symbolContext.class);
		}
		public Function_name_or_symbolContext function_name_or_symbol(int i) {
			return getRuleContext(Function_name_or_symbolContext.class,i);
		}
		public Alias_statementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alias_statement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitAlias_statement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Alias_statementContext alias_statement() throws RecognitionException {
		Alias_statementContext _localctx = new Alias_statementContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_alias_statement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(180);
			match(ALIAS);
			setState(181);
			function_name_or_symbol();
			setState(182);
			function_name_or_symbol();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_name_or_symbolContext extends ParserRuleContext {
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public Function_name_or_symbolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_name_or_symbol; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_name_or_symbol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_name_or_symbolContext function_name_or_symbol() throws RecognitionException {
		Function_name_or_symbolContext _localctx = new Function_name_or_symbolContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_function_name_or_symbol);
		try {
			setState(186);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SYNTAXERROR:
			case BREAK:
			case FALSE:
			case NEXT:
			case NIL:
			case REDO:
			case RETRY:
			case SELF:
			case SUPER:
			case TRUE:
			case Integer:
			case Float:
			case String:
			case DollarSpecial:
			case AND:
			case OR:
			case PLUS:
			case MINUS:
			case MOD:
			case PLUS_ASSIGN:
			case MOD_ASSIGN:
			case AND_ASSIGN:
			case BIT_AND_ASSIGN:
			case BIT_AND:
			case EXP_ASSIGN:
			case EXP:
			case MUL:
			case MUL_ASSIGN:
			case DOLLAR:
			case AT:
			case LEFT_PAREN:
			case LEFT_SBRACKET:
			case DIV_ASSIGN:
			case DIV:
			case NOT_EQUAL:
			case MINUS_ASSIGN:
			case OR_ASSIGN:
			case BIT_OR_ASSIGN:
			case BIT_OR:
			case BIT_SHR_ASSIGN:
			case GREATER_EQUAL:
			case BIT_SHR:
			case GREATER:
			case EQUAL3:
			case EQUAL:
			case LESS_EQUAL:
			case LESS:
			case BIT_SHL_ASSIGN:
			case BIT_SHL:
			case BIT_NOT_ASSIGN:
			case BIT_XOR_ASSIGN:
			case BIT_XOR:
			case Identifier:
			case ShellCommand:
				enterOuterAlt(_localctx, 1);
				{
				setState(184);
				function_name();
				}
				break;
			case COLON:
				enterOuterAlt(_localctx, 2);
				{
				setState(185);
				symbol();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ImportsContext extends ParserRuleContext {
		public List<PrimaryContext> primary() {
			return getRuleContexts(PrimaryContext.class);
		}
		public PrimaryContext primary(int i) {
			return getRuleContext(PrimaryContext.class,i);
		}
		public List<TermsContext> terms() {
			return getRuleContexts(TermsContext.class);
		}
		public TermsContext terms(int i) {
			return getRuleContext(TermsContext.class,i);
		}
		public List<TerminalNode> LOAD() { return getTokens(RubyParser.LOAD); }
		public TerminalNode LOAD(int i) {
			return getToken(RubyParser.LOAD, i);
		}
		public List<TerminalNode> REQUIRE() { return getTokens(RubyParser.REQUIRE); }
		public TerminalNode REQUIRE(int i) {
			return getToken(RubyParser.REQUIRE, i);
		}
		public List<TerminalNode> REQUIRE_RELATIVE() { return getTokens(RubyParser.REQUIRE_RELATIVE); }
		public TerminalNode REQUIRE_RELATIVE(int i) {
			return getToken(RubyParser.REQUIRE_RELATIVE, i);
		}
		public ImportsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_imports; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitImports(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportsContext imports() throws RecognitionException {
		ImportsContext _localctx = new ImportsContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_imports);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(192); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(188);
					_la = _input.LA(1);
					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 114688L) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(189);
					primary();
					setState(190);
					terms();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(194); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Begin_blockContext extends ParserRuleContext {
		public TerminalNode BEGIN_BLOCK() { return getToken(RubyParser.BEGIN_BLOCK, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(RubyParser.LEFT_PAREN, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(RubyParser.RIGHT_PAREN, 0); }
		public Begin_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_begin_block; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitBegin_block(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Begin_blockContext begin_block() throws RecognitionException {
		Begin_blockContext _localctx = new Begin_blockContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_begin_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(196);
			match(BEGIN_BLOCK);
			setState(197);
			match(LEFT_PAREN);
			setState(198);
			statement_list_terms(0);
			setState(199);
			match(RIGHT_PAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class End_blockContext extends ParserRuleContext {
		public TerminalNode END_BLOCK() { return getToken(RubyParser.END_BLOCK, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(RubyParser.LEFT_PAREN, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(RubyParser.RIGHT_PAREN, 0); }
		public End_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_end_block; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitEnd_block(this);
			else return visitor.visitChildren(this);
		}
	}

	public final End_blockContext end_block() throws RecognitionException {
		End_blockContext _localctx = new End_blockContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_end_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(201);
			match(END_BLOCK);
			setState(202);
			match(LEFT_PAREN);
			setState(203);
			statement_list_terms(0);
			setState(204);
			match(RIGHT_PAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Module_definitionContext extends ParserRuleContext {
		public TerminalNode MODULE() { return getToken(RubyParser.MODULE, 0); }
		public CpathContext cpath() {
			return getRuleContext(CpathContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Module_definitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_module_definition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitModule_definition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Module_definitionContext module_definition() throws RecognitionException {
		Module_definitionContext _localctx = new Module_definitionContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_module_definition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(206);
			match(MODULE);
			setState(207);
			cpath();
			setState(209);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				{
				setState(208);
				statement_list_terms(0);
				}
				break;
			}
			setState(211);
			match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Class_definitionContext extends ParserRuleContext {
		public Class_headerContext class_header() {
			return getRuleContext(Class_headerContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Class_definitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_class_definition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitClass_definition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Class_definitionContext class_definition() throws RecognitionException {
		Class_definitionContext _localctx = new Class_definitionContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_class_definition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(213);
			class_header();
			setState(215);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(214);
				statement_list_terms(0);
				}
				break;
			}
			setState(217);
			match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SuperclassContext extends ParserRuleContext {
		public TerminalNode LESS() { return getToken(RubyParser.LESS, 0); }
		public Id_symbolContext id_symbol() {
			return getRuleContext(Id_symbolContext.class,0);
		}
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public SuperclassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_superclass; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitSuperclass(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SuperclassContext superclass() throws RecognitionException {
		SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_superclass);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(219);
			match(LESS);
			setState(220);
			id_symbol();
			setState(221);
			terms();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Class_headerContext extends ParserRuleContext {
		public TerminalNode CLASS() { return getToken(RubyParser.CLASS, 0); }
		public CpathContext cpath() {
			return getRuleContext(CpathContext.class,0);
		}
		public SuperclassContext superclass() {
			return getRuleContext(SuperclassContext.class,0);
		}
		public TerminalNode BIT_SHL() { return getToken(RubyParser.BIT_SHL, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public Class_headerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_class_header; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitClass_header(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Class_headerContext class_header() throws RecognitionException {
		Class_headerContext _localctx = new Class_headerContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_class_header);
		try {
			setState(231);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(223);
				match(CLASS);
				setState(224);
				cpath();
				setState(226);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
				case 1:
					{
					setState(225);
					superclass();
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(228);
				match(CLASS);
				setState(229);
				match(BIT_SHL);
				setState(230);
				identifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_definitionContext extends ParserRuleContext {
		public Function_definition_headerContext function_definition_header() {
			return getRuleContext(Function_definition_headerContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Function_definitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_definition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_definition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_definitionContext function_definition() throws RecognitionException {
		Function_definitionContext _localctx = new Function_definitionContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_function_definition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(233);
			function_definition_header();
			setState(235);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				{
				setState(234);
				statement_list_terms(0);
				}
				break;
			}
			setState(237);
			match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_definition_headerContext extends ParserRuleContext {
		public TerminalNode DEF() { return getToken(RubyParser.DEF, 0); }
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public Function_definition_paramsContext function_definition_params() {
			return getRuleContext(Function_definition_paramsContext.class,0);
		}
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Function_definition_headerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_definition_header; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_definition_header(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_definition_headerContext function_definition_header() throws RecognitionException {
		Function_definition_headerContext _localctx = new Function_definition_headerContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_function_definition_header);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(239);
			match(DEF);
			setState(240);
			function_name();
			setState(242);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				{
				setState(241);
				function_definition_params();
				}
				break;
			}
			setState(245);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(244);
				expr(0);
				}
				break;
			}
			setState(247);
			terms();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_nameContext extends ParserRuleContext {
		public CpathContext cpath() {
			return getRuleContext(CpathContext.class,0);
		}
		public TerminalNode QUESTION() { return getToken(RubyParser.QUESTION, 0); }
		public TerminalNode SIGH() { return getToken(RubyParser.SIGH, 0); }
		public TerminalNode ASSIGN() { return getToken(RubyParser.ASSIGN, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public AssignOperatorContext assignOperator() {
			return getRuleContext(AssignOperatorContext.class,0);
		}
		public MathOperatorContext mathOperator() {
			return getRuleContext(MathOperatorContext.class,0);
		}
		public TerminalNode AT() { return getToken(RubyParser.AT, 0); }
		public BitOperatorContext bitOperator() {
			return getRuleContext(BitOperatorContext.class,0);
		}
		public CompareOperatorContext compareOperator() {
			return getRuleContext(CompareOperatorContext.class,0);
		}
		public EqualsOperatorContext equalsOperator() {
			return getRuleContext(EqualsOperatorContext.class,0);
		}
		public LogicalOperatorContext logicalOperator() {
			return getRuleContext(LogicalOperatorContext.class,0);
		}
		public Function_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_name; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_name(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_nameContext function_name() throws RecognitionException {
		Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_function_name);
		int _la;
		try {
			setState(262);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(249);
				cpath();
				setState(251);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
				case 1:
					{
					setState(250);
					_la = _input.LA(1);
					if ( !(((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 32773L) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(253);
				literal();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(254);
				assignOperator();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(255);
				mathOperator();
				setState(256);
				match(AT);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(258);
				bitOperator();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(259);
				compareOperator();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(260);
				equalsOperator();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(261);
				logicalOperator();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_definition_paramsContext extends ParserRuleContext {
		public TerminalNode LEFT_RBRACKET() { return getToken(RubyParser.LEFT_RBRACKET, 0); }
		public TerminalNode RIGHT_RBRACKET() { return getToken(RubyParser.RIGHT_RBRACKET, 0); }
		public List<Function_definition_paramContext> function_definition_param() {
			return getRuleContexts(Function_definition_paramContext.class);
		}
		public Function_definition_paramContext function_definition_param(int i) {
			return getRuleContext(Function_definition_paramContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public Function_definition_paramsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_definition_params; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_definition_params(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_definition_paramsContext function_definition_params() throws RecognitionException {
		Function_definition_paramsContext _localctx = new Function_definition_paramsContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_function_definition_params);
		int _la;
		try {
			int _alt;
			setState(290);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(264);
				match(LEFT_RBRACKET);
				setState(276);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -576814814342135840L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 225159087385132983L) != 0)) {
					{
					setState(265);
					function_definition_param();
					setState(273);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(266);
						match(COMMA);
						setState(268);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(267);
							crlfs();
							}
						}

						setState(270);
						function_definition_param();
						}
						}
						setState(275);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				setState(278);
				match(RIGHT_RBRACKET);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(279);
				function_definition_param();
				setState(287);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(280);
						match(COMMA);
						setState(282);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(281);
							crlfs();
							}
						}

						setState(284);
						function_definition_param();
						}
						} 
					}
					setState(289);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_definition_paramContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode MUL() { return getToken(RubyParser.MUL, 0); }
		public TerminalNode EXP() { return getToken(RubyParser.EXP, 0); }
		public TerminalNode BIT_AND() { return getToken(RubyParser.BIT_AND, 0); }
		public Hash_assoContext hash_asso() {
			return getRuleContext(Hash_assoContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(RubyParser.ASSIGN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Function_definition_paramContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_definition_param; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_definition_param(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_definition_paramContext function_definition_param() throws RecognitionException {
		Function_definition_paramContext _localctx = new Function_definition_paramContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_function_definition_param);
		try {
			setState(304);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(292);
				identifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(293);
				match(MUL);
				setState(294);
				identifier();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(295);
				match(EXP);
				setState(296);
				identifier();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(297);
				match(BIT_AND);
				setState(298);
				identifier();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(299);
				hash_asso();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(300);
				identifier();
				setState(301);
				match(ASSIGN);
				setState(302);
				expr(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Function_call_paramContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Hash_assoContext hash_asso() {
			return getRuleContext(Hash_assoContext.class,0);
		}
		public Function_call_paramContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_call_param; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunction_call_param(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_call_paramContext function_call_param() throws RecognitionException {
		Function_call_paramContext _localctx = new Function_call_paramContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_function_call_param);
		try {
			setState(308);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(306);
				expr(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(307);
				hash_asso();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExprContext extends ParserRuleContext {
		public ExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr; }
	 
		public ExprContext() { }
		public void copyFrom(ExprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprLogicalNotContext extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public NotContext not() {
			return getRuleContext(NotContext.class,0);
		}
		public TerminalNode BIT_NOT() { return getToken(RubyParser.BIT_NOT, 0); }
		public ExprLogicalNotContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprLogicalNot(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPrintContext extends ExprContext {
		public PrintContext print() {
			return getRuleContext(PrintContext.class,0);
		}
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public ExprPrintContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPrint(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprDotClassContext extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Dot_refContext dot_ref() {
			return getRuleContext(Dot_refContext.class,0);
		}
		public TerminalNode CLASS() { return getToken(RubyParser.CLASS, 0); }
		public ExprDotClassContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprDotClass(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprCalcuationContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public MathOperatorContext mathOperator() {
			return getRuleContext(MathOperatorContext.class,0);
		}
		public BitOperatorContext bitOperator() {
			return getRuleContext(BitOperatorContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprCalcuationContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprCalcuation(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPrimaryContext extends ExprContext {
		public PrimaryContext primary() {
			return getRuleContext(PrimaryContext.class,0);
		}
		public ExprPrimaryContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPrimary(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprCompareLogicalContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public CompareOperatorContext compareOperator() {
			return getRuleContext(CompareOperatorContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprCompareLogicalContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprCompareLogical(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprBatchAssignContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode ASSIGN() { return getToken(RubyParser.ASSIGN, 0); }
		public TerminalNode COMMA() { return getToken(RubyParser.COMMA, 0); }
		public TerminalNode MUL() { return getToken(RubyParser.MUL, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprBatchAssignContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprBatchAssign(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPatternMatch2Context extends ExprContext {
		public Token bop;
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode BIT_NOT() { return getToken(RubyParser.BIT_NOT, 0); }
		public ExprPatternMatch2Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPatternMatch2(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPatternMatch3Context extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode SIGH() { return getToken(RubyParser.SIGH, 0); }
		public TerminalNode BIT_NOT() { return getToken(RubyParser.BIT_NOT, 0); }
		public ExprPatternMatch3Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPatternMatch3(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPrefixCalcContext extends ExprContext {
		public Token prefix;
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode PLUS() { return getToken(RubyParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(RubyParser.MINUS, 0); }
		public TerminalNode MUL() { return getToken(RubyParser.MUL, 0); }
		public TerminalNode MOD() { return getToken(RubyParser.MOD, 0); }
		public TerminalNode BIT_AND() { return getToken(RubyParser.BIT_AND, 0); }
		public ExprPrefixCalcContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPrefixCalc(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprFunctionCall3Context extends ExprContext {
		public CpathContext cpath() {
			return getRuleContext(CpathContext.class,0);
		}
		public TerminalNode QUESTION() { return getToken(RubyParser.QUESTION, 0); }
		public TerminalNode SIGH() { return getToken(RubyParser.SIGH, 0); }
		public ExprFunctionCall3Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprFunctionCall3(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprQuestionContext extends ExprContext {
		public Token postfix;
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode QUESTION() { return getToken(RubyParser.QUESTION, 0); }
		public ExprQuestionContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprQuestion(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprFunctionCall2Context extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Dot_refContext dot_ref() {
			return getRuleContext(Dot_refContext.class,0);
		}
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public Func_call_parameters_no_bracketContext func_call_parameters_no_bracket() {
			return getRuleContext(Func_call_parameters_no_bracketContext.class,0);
		}
		public Expr_statement_suffixContext expr_statement_suffix() {
			return getRuleContext(Expr_statement_suffixContext.class,0);
		}
		public ExprFunctionCall2Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprFunctionCall2(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprFunctionCall1Context extends ExprContext {
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public Func_call_parameters_no_bracketContext func_call_parameters_no_bracket() {
			return getRuleContext(Func_call_parameters_no_bracketContext.class,0);
		}
		public Expr_statement_suffixContext expr_statement_suffix() {
			return getRuleContext(Expr_statement_suffixContext.class,0);
		}
		public ExprFunctionCall1Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprFunctionCall1(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprEqualTestContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public EqualsOperatorContext equalsOperator() {
			return getRuleContext(EqualsOperatorContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprEqualTestContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprEqualTest(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprIncludeContext extends ExprContext {
		public IncluContext inclu() {
			return getRuleContext(IncluContext.class,0);
		}
		public PrimaryContext primary() {
			return getRuleContext(PrimaryContext.class,0);
		}
		public ExprIncludeContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprInclude(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprRangeContext extends ExprContext {
		public Token bop;
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode DOT2() { return getToken(RubyParser.DOT2, 0); }
		public TerminalNode DOT3() { return getToken(RubyParser.DOT3, 0); }
		public ExprRangeContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprRange(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprPatternMatch1Context extends ExprContext {
		public Token bop;
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode PATTERN_MATCH() { return getToken(RubyParser.PATTERN_MATCH, 0); }
		public ExprPatternMatch1Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprPatternMatch1(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprSymbolliteralContext extends ExprContext {
		public TerminalNode Digits() { return getToken(RubyParser.Digits, 0); }
		public TerminalNode PLUS() { return getToken(RubyParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(RubyParser.MINUS, 0); }
		public TerminalNode ExponentPart() { return getToken(RubyParser.ExponentPart, 0); }
		public TerminalNode NumberTypeSuffix() { return getToken(RubyParser.NumberTypeSuffix, 0); }
		public ExprSymbolliteralContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprSymbolliteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprBlockContext extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public ExprBlockContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprBlock(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprLogicalJoinContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public LogicalOperatorContext logicalOperator() {
			return getRuleContext(LogicalOperatorContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprLogicalJoinContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprLogicalJoin(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprArrayAccessContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode LEFT_SBRACKET() { return getToken(RubyParser.LEFT_SBRACKET, 0); }
		public TerminalNode RIGHT_SBRACKET() { return getToken(RubyParser.RIGHT_SBRACKET, 0); }
		public ExprArrayAccessContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprArrayAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprConditionStatementContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode QUESTION() { return getToken(RubyParser.QUESTION, 0); }
		public TerminalNode COLON() { return getToken(RubyParser.COLON, 0); }
		public ExprConditionStatementContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprConditionStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprWitStatementSuffixContext extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Expr_statement_suffixContext expr_statement_suffix() {
			return getRuleContext(Expr_statement_suffixContext.class,0);
		}
		public ExprWitStatementSuffixContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprWitStatementSuffix(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprDefineTestContext extends ExprContext {
		public Token prefix;
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode DEFINED() { return getToken(RubyParser.DEFINED, 0); }
		public ExprDefineTestContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprDefineTest(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprListContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode COMMA() { return getToken(RubyParser.COMMA, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprListContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprList(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprDotRefContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Dot_refContext dot_ref() {
			return getRuleContext(Dot_refContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprDotRefContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprDotRef(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExprAssignContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public AssignOperatorContext assignOperator() {
			return getRuleContext(AssignOperatorContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public ExprAssignContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExprAssign(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprContext expr() throws RecognitionException {
		return expr(0);
	}

	private ExprContext expr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExprContext _localctx = new ExprContext(_ctx, _parentState);
		ExprContext _prevctx = _localctx;
		int _startState = 40;
		enterRecursionRule(_localctx, 40, RULE_expr, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(343);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
			case 1:
				{
				_localctx = new ExprPrimaryContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(311);
				primary();
				}
				break;
			case 2:
				{
				_localctx = new ExprIncludeContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(312);
				inclu();
				setState(313);
				primary();
				}
				break;
			case 3:
				{
				_localctx = new ExprPrintContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(315);
				print();
				setState(316);
				expr(24);
				}
				break;
			case 4:
				{
				_localctx = new ExprPrefixCalcContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(318);
				((ExprPrefixCalcContext)_localctx).prefix = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & 4615L) != 0)) ) {
					((ExprPrefixCalcContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(319);
				expr(21);
				}
				break;
			case 5:
				{
				_localctx = new ExprDefineTestContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(320);
				((ExprDefineTestContext)_localctx).prefix = match(DEFINED);
				setState(321);
				expr(19);
				}
				break;
			case 6:
				{
				_localctx = new ExprLogicalNotContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(324);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case NOT:
				case SIGH:
					{
					setState(322);
					not();
					}
					break;
				case BIT_NOT:
					{
					setState(323);
					match(BIT_NOT);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(326);
				expr(13);
				}
				break;
			case 7:
				{
				_localctx = new ExprFunctionCall1Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(327);
				function_name();
				setState(328);
				func_call_parameters_no_bracket();
				setState(330);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
				case 1:
					{
					setState(329);
					expr_statement_suffix();
					}
					break;
				}
				}
				break;
			case 8:
				{
				_localctx = new ExprFunctionCall3Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(332);
				cpath();
				setState(333);
				_la = _input.LA(1);
				if ( !(_la==QUESTION || _la==SIGH) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case 9:
				{
				_localctx = new ExprSymbolliteralContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(335);
				_la = _input.LA(1);
				if ( !(_la==PLUS || _la==MINUS) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(336);
				match(Digits);
				setState(338);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
				case 1:
					{
					setState(337);
					match(ExponentPart);
					}
					break;
				}
				setState(341);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
				case 1:
					{
					setState(340);
					match(NumberTypeSuffix);
					}
					break;
				}
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(453);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(451);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
					case 1:
						{
						_localctx = new ExprCalcuationContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(345);
						if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)");
						setState(348);
						_errHandler.sync(this);
						switch (_input.LA(1)) {
						case PLUS:
						case MINUS:
						case MOD:
						case EXP:
						case MUL:
						case DIV:
							{
							setState(346);
							mathOperator();
							}
							break;
						case BIT_AND:
						case BIT_OR:
						case BIT_SHR:
						case BIT_SHL:
						case BIT_XOR:
							{
							setState(347);
							bitOperator();
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						setState(351);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(350);
							crlfs();
							}
						}

						setState(353);
						expr(29);
						}
						break;
					case 2:
						{
						_localctx = new ExprListContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(355);
						if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)");
						setState(356);
						match(COMMA);
						setState(358);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(357);
							crlfs();
							}
						}

						setState(360);
						expr(28);
						}
						break;
					case 3:
						{
						_localctx = new ExprDotRefContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(361);
						if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
						setState(362);
						dot_ref();
						setState(364);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(363);
							crlfs();
							}
						}

						setState(366);
						expr(24);
						}
						break;
					case 4:
						{
						_localctx = new ExprBatchAssignContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(368);
						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
						setState(370);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==COMMA) {
							{
							setState(369);
							match(COMMA);
							}
						}

						setState(373);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==MUL) {
							{
							setState(372);
							match(MUL);
							}
						}

						setState(375);
						match(ASSIGN);
						setState(377);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(376);
							crlfs();
							}
						}

						setState(379);
						expr(18);
						}
						break;
					case 5:
						{
						_localctx = new ExprPatternMatch1Context(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(380);
						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
						setState(381);
						((ExprPatternMatch1Context)_localctx).bop = match(PATTERN_MATCH);
						setState(382);
						expr(17);
						}
						break;
					case 6:
						{
						_localctx = new ExprPatternMatch2Context(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(383);
						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
						setState(384);
						((ExprPatternMatch2Context)_localctx).bop = match(BIT_NOT);
						setState(385);
						expr(16);
						}
						break;
					case 7:
						{
						_localctx = new ExprPatternMatch3Context(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(386);
						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
						setState(387);
						match(SIGH);
						setState(388);
						match(BIT_NOT);
						setState(389);
						expr(15);
						}
						break;
					case 8:
						{
						_localctx = new ExprCompareLogicalContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(390);
						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
						{
						setState(391);
						compareOperator();
						}
						setState(393);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(392);
							crlfs();
							}
						}

						setState(395);
						expr(13);
						}
						break;
					case 9:
						{
						_localctx = new ExprLogicalJoinContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(397);
						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
						{
						setState(398);
						logicalOperator();
						}
						setState(400);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(399);
							crlfs();
							}
						}

						setState(402);
						expr(12);
						}
						break;
					case 10:
						{
						_localctx = new ExprEqualTestContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(404);
						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
						{
						setState(405);
						equalsOperator();
						}
						setState(407);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(406);
							crlfs();
							}
						}

						setState(409);
						expr(11);
						}
						break;
					case 11:
						{
						_localctx = new ExprAssignContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(411);
						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
						setState(412);
						assignOperator();
						setState(414);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(413);
							crlfs();
							}
						}

						setState(416);
						expr(10);
						}
						break;
					case 12:
						{
						_localctx = new ExprConditionStatementContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(418);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(419);
						match(QUESTION);
						setState(420);
						expr(0);
						setState(421);
						match(COLON);
						setState(422);
						expr(9);
						}
						break;
					case 13:
						{
						_localctx = new ExprQuestionContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(424);
						if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
						setState(425);
						((ExprQuestionContext)_localctx).postfix = match(QUESTION);
						}
						break;
					case 14:
						{
						_localctx = new ExprArrayAccessContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(426);
						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
						setState(427);
						match(LEFT_SBRACKET);
						setState(428);
						expr(0);
						setState(429);
						match(RIGHT_SBRACKET);
						}
						break;
					case 15:
						{
						_localctx = new ExprRangeContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(431);
						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
						setState(432);
						((ExprRangeContext)_localctx).bop = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==DOT3 || _la==DOT2) ) {
							((ExprRangeContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(434);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
						case 1:
							{
							setState(433);
							expr(0);
							}
							break;
						}
						}
						break;
					case 16:
						{
						_localctx = new ExprBlockContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(436);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(437);
						block();
						}
						break;
					case 17:
						{
						_localctx = new ExprWitStatementSuffixContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(438);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(439);
						expr_statement_suffix();
						}
						break;
					case 18:
						{
						_localctx = new ExprDotClassContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(440);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(441);
						dot_ref();
						setState(442);
						match(CLASS);
						}
						break;
					case 19:
						{
						_localctx = new ExprFunctionCall2Context(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(444);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(445);
						dot_ref();
						setState(446);
						function_name();
						setState(447);
						func_call_parameters_no_bracket();
						setState(449);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
						case 1:
							{
							setState(448);
							expr_statement_suffix();
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(455);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Expr_statement_suffixContext extends ParserRuleContext {
		public TerminalNode IF() { return getToken(RubyParser.IF, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public TerminalNode UNLESS() { return getToken(RubyParser.UNLESS, 0); }
		public TerminalNode WHILE() { return getToken(RubyParser.WHILE, 0); }
		public TerminalNode UNTIL() { return getToken(RubyParser.UNTIL, 0); }
		public TerminalNode RESCUE() { return getToken(RubyParser.RESCUE, 0); }
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public TerminalNode DO() { return getToken(RubyParser.DO, 0); }
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public Block_paramsContext block_params() {
			return getRuleContext(Block_paramsContext.class,0);
		}
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Expr_statement_suffixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr_statement_suffix; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitExpr_statement_suffix(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expr_statement_suffixContext expr_statement_suffix() throws RecognitionException {
		Expr_statement_suffixContext _localctx = new Expr_statement_suffixContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_expr_statement_suffix);
		int _la;
		try {
			setState(489);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IF:
				enterOuterAlt(_localctx, 1);
				{
				setState(456);
				match(IF);
				setState(458);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(457);
					crlfs();
					}
				}

				setState(460);
				expr(0);
				}
				break;
			case UNLESS:
				enterOuterAlt(_localctx, 2);
				{
				setState(461);
				match(UNLESS);
				setState(463);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(462);
					crlfs();
					}
				}

				setState(465);
				expr(0);
				}
				break;
			case WHILE:
				enterOuterAlt(_localctx, 3);
				{
				setState(466);
				match(WHILE);
				setState(468);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(467);
					crlfs();
					}
				}

				setState(470);
				expr(0);
				}
				break;
			case UNTIL:
				enterOuterAlt(_localctx, 4);
				{
				setState(471);
				match(UNTIL);
				setState(473);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(472);
					crlfs();
					}
				}

				setState(475);
				expr(0);
				}
				break;
			case RESCUE:
				enterOuterAlt(_localctx, 5);
				{
				setState(476);
				match(RESCUE);
				setState(477);
				statement();
				}
				break;
			case DO:
				enterOuterAlt(_localctx, 6);
				{
				setState(478);
				match(DO);
				setState(480);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
				case 1:
					{
					setState(479);
					block_params();
					}
					break;
				}
				setState(483);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
				case 1:
					{
					setState(482);
					terms();
					}
					break;
				}
				setState(486);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
				case 1:
					{
					setState(485);
					statement_list_terms(0);
					}
					break;
				}
				setState(488);
				match(END);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryContext extends ParserRuleContext {
		public PrimaryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primary; }
	 
		public PrimaryContext() { }
		public void copyFrom(PrimaryContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryVarPathContext extends PrimaryContext {
		public Variable_pathContext variable_path() {
			return getRuleContext(Variable_pathContext.class,0);
		}
		public PrimaryVarPathContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryVarPath(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryStatementReturnContext extends PrimaryContext {
		public TerminalNode RETURN() { return getToken(RubyParser.RETURN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public PrimaryStatementReturnContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryStatementReturn(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryRetryContext extends PrimaryContext {
		public RetryContext retry() {
			return getRuleContext(RetryContext.class,0);
		}
		public PrimaryRetryContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryRetry(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockModelDefContext extends PrimaryContext {
		public Module_definitionContext module_definition() {
			return getRuleContext(Module_definitionContext.class,0);
		}
		public PrimaryBlockModelDefContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockModelDef(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryFunctionCall0Context extends PrimaryContext {
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public Func_call_parametersContext func_call_parameters() {
			return getRuleContext(Func_call_parametersContext.class,0);
		}
		public PrimaryFunctionCall0Context(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryFunctionCall0(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryListExprContext extends PrimaryContext {
		public TerminalNode LEFT_SBRACKET() { return getToken(RubyParser.LEFT_SBRACKET, 0); }
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode RIGHT_SBRACKET() { return getToken(RubyParser.RIGHT_SBRACKET, 0); }
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public PrimaryListExprContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryListExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockCase1Context extends PrimaryContext {
		public TerminalNode CASE() { return getToken(RubyParser.CASE, 0); }
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public TerminalNode DOLLAR() { return getToken(RubyParser.DOLLAR, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public List<Case_bodyContext> case_body() {
			return getRuleContexts(Case_bodyContext.class);
		}
		public Case_bodyContext case_body(int i) {
			return getRuleContext(Case_bodyContext.class,i);
		}
		public PrimaryBlockCase1Context(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockCase1(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryModifierContext extends PrimaryContext {
		public ModifierContext modifier() {
			return getRuleContext(ModifierContext.class,0);
		}
		public PrimaryModifierContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryModifier(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockContext extends PrimaryContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public PrimaryBlockContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlock(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockUntilContext extends PrimaryContext {
		public TerminalNode UNTIL() { return getToken(RubyParser.UNTIL, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Do_keywordContext do_keyword() {
			return getRuleContext(Do_keywordContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public PrimaryBlockUntilContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockUntil(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockUnlessContext extends PrimaryContext {
		public TerminalNode UNLESS() { return getToken(RubyParser.UNLESS, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Then_keywordContext then_keyword() {
			return getRuleContext(Then_keywordContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Else_tailContext else_tail() {
			return getRuleContext(Else_tailContext.class,0);
		}
		public PrimaryBlockUnlessContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockUnless(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryStatementBreakContext extends PrimaryContext {
		public TerminalNode BREAK() { return getToken(RubyParser.BREAK, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public PrimaryStatementBreakContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryStatementBreak(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockIfContext extends PrimaryContext {
		public TerminalNode IF() { return getToken(RubyParser.IF, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Then_keywordContext then_keyword() {
			return getRuleContext(Then_keywordContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public List<If_tailContext> if_tail() {
			return getRuleContexts(If_tailContext.class);
		}
		public If_tailContext if_tail(int i) {
			return getRuleContext(If_tailContext.class,i);
		}
		public PrimaryBlockIfContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockIf(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockForContext extends PrimaryContext {
		public TerminalNode FOR() { return getToken(RubyParser.FOR, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode IN() { return getToken(RubyParser.IN, 0); }
		public When_condContext when_cond() {
			return getRuleContext(When_condContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public TerminalNode DO() { return getToken(RubyParser.DO, 0); }
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public PrimaryBlockForContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockFor(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryRangeContext extends PrimaryContext {
		public TerminalNode LEFT_RBRACKET() { return getToken(RubyParser.LEFT_RBRACKET, 0); }
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode RIGHT_RBRACKET() { return getToken(RubyParser.RIGHT_RBRACKET, 0); }
		public TerminalNode DOT2() { return getToken(RubyParser.DOT2, 0); }
		public TerminalNode DOT3() { return getToken(RubyParser.DOT3, 0); }
		public PrimaryRangeContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryRange(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryStatementRaiseContext extends PrimaryContext {
		public TerminalNode RAISE() { return getToken(RubyParser.RAISE, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public PrimaryStatementRaiseContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryStatementRaise(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryRegexContext extends PrimaryContext {
		public TerminalNode Regex() { return getToken(RubyParser.Regex, 0); }
		public PrimaryRegexContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryRegex(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryStatementYieldContext extends PrimaryContext {
		public TerminalNode YIELD() { return getToken(RubyParser.YIELD, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public PrimaryStatementYieldContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryStatementYield(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockFunctionDefContext extends PrimaryContext {
		public Function_definitionContext function_definition() {
			return getRuleContext(Function_definitionContext.class,0);
		}
		public PrimaryBlockFunctionDefContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockFunctionDef(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBracketContext extends PrimaryContext {
		public TerminalNode LEFT_RBRACKET() { return getToken(RubyParser.LEFT_RBRACKET, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode RIGHT_RBRACKET() { return getToken(RubyParser.RIGHT_RBRACKET, 0); }
		public PrimaryBracketContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBracket(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockClassDefContext extends PrimaryContext {
		public Class_definitionContext class_definition() {
			return getRuleContext(Class_definitionContext.class,0);
		}
		public PrimaryBlockClassDefContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockClassDef(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBeginBlockContext extends PrimaryContext {
		public TerminalNode BEGIN() { return getToken(RubyParser.BEGIN, 0); }
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public List<Statement_list_termsContext> statement_list_terms() {
			return getRuleContexts(Statement_list_termsContext.class);
		}
		public Statement_list_termsContext statement_list_terms(int i) {
			return getRuleContext(Statement_list_termsContext.class,i);
		}
		public RescuestatementContext rescuestatement() {
			return getRuleContext(RescuestatementContext.class,0);
		}
		public EnsureContext ensure() {
			return getRuleContext(EnsureContext.class,0);
		}
		public PrimaryBeginBlockContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBeginBlock(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockWhenContext extends PrimaryContext {
		public TerminalNode WHEN() { return getToken(RubyParser.WHEN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Then_keywordContext then_keyword() {
			return getRuleContext(Then_keywordContext.class,0);
		}
		public Statement_list_notermsContext statement_list_noterms() {
			return getRuleContext(Statement_list_notermsContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public PrimaryBlockWhenContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockWhen(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryListHashContext extends PrimaryContext {
		public TerminalNode LEFT_PAREN() { return getToken(RubyParser.LEFT_PAREN, 0); }
		public List<Hash_assoContext> hash_asso() {
			return getRuleContexts(Hash_assoContext.class);
		}
		public Hash_assoContext hash_asso(int i) {
			return getRuleContext(Hash_assoContext.class,i);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(RubyParser.RIGHT_PAREN, 0); }
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public PrimaryListHashContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryListHash(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryBlockWhileContext extends PrimaryContext {
		public TerminalNode WHILE() { return getToken(RubyParser.WHILE, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Do_keywordContext do_keyword() {
			return getRuleContext(Do_keywordContext.class,0);
		}
		public TerminalNode END() { return getToken(RubyParser.END, 0); }
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public PrimaryBlockWhileContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimaryBlockWhile(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PrimarySymbolContext extends PrimaryContext {
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public PrimarySymbolContext(PrimaryContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrimarySymbol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimaryContext primary() throws RecognitionException {
		PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_primary);
		int _la;
		try {
			int _alt;
			setState(686);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
			case 1:
				_localctx = new PrimaryRegexContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(491);
				match(Regex);
				}
				break;
			case 2:
				_localctx = new PrimaryRetryContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(492);
				retry();
				}
				break;
			case 3:
				_localctx = new PrimaryModifierContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(493);
				modifier();
				}
				break;
			case 4:
				_localctx = new PrimarySymbolContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(494);
				symbol();
				}
				break;
			case 5:
				_localctx = new PrimaryBracketContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(495);
				match(LEFT_RBRACKET);
				setState(496);
				expr(0);
				setState(497);
				match(RIGHT_RBRACKET);
				}
				break;
			case 6:
				_localctx = new PrimaryBlockContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(499);
				block();
				}
				break;
			case 7:
				_localctx = new PrimaryStatementBreakContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(500);
				match(BREAK);
				setState(502);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
				case 1:
					{
					setState(501);
					expr(0);
					}
					break;
				}
				}
				break;
			case 8:
				_localctx = new PrimaryStatementReturnContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(504);
				match(RETURN);
				setState(506);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
				case 1:
					{
					setState(505);
					expr(0);
					}
					break;
				}
				}
				break;
			case 9:
				_localctx = new PrimaryStatementRaiseContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(508);
				match(RAISE);
				setState(509);
				expr(0);
				}
				break;
			case 10:
				_localctx = new PrimaryStatementYieldContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(510);
				match(YIELD);
				setState(512);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
				case 1:
					{
					setState(511);
					expr(0);
					}
					break;
				}
				}
				break;
			case 11:
				_localctx = new PrimaryBeginBlockContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(514);
				match(BEGIN);
				setState(515);
				terms();
				setState(517);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
				case 1:
					{
					setState(516);
					statement_list_terms(0);
					}
					break;
				}
				setState(520);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
				case 1:
					{
					setState(519);
					rescuestatement();
					}
					break;
				}
				setState(523);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
				case 1:
					{
					setState(522);
					ensure();
					}
					break;
				}
				setState(526);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
				case 1:
					{
					setState(525);
					statement_list_terms(0);
					}
					break;
				}
				setState(528);
				match(END);
				}
				break;
			case 12:
				_localctx = new PrimaryBlockIfContext(_localctx);
				enterOuterAlt(_localctx, 12);
				{
				setState(530);
				match(IF);
				setState(532);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(531);
					crlfs();
					}
				}

				setState(534);
				expr(0);
				setState(535);
				then_keyword();
				setState(537);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
				case 1:
					{
					setState(536);
					statement_list_terms(0);
					}
					break;
				}
				setState(542);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==ELSE || _la==ELSIF) {
					{
					{
					setState(539);
					if_tail();
					}
					}
					setState(544);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(545);
				match(END);
				}
				break;
			case 13:
				_localctx = new PrimaryBlockWhenContext(_localctx);
				enterOuterAlt(_localctx, 13);
				{
				setState(547);
				match(WHEN);
				setState(548);
				expr(0);
				setState(549);
				then_keyword();
				setState(550);
				statement_list_noterms();
				setState(551);
				match(END);
				}
				break;
			case 14:
				_localctx = new PrimaryBlockUnlessContext(_localctx);
				enterOuterAlt(_localctx, 14);
				{
				setState(553);
				match(UNLESS);
				setState(555);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(554);
					crlfs();
					}
				}

				setState(557);
				expr(0);
				setState(558);
				then_keyword();
				setState(560);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
				case 1:
					{
					setState(559);
					statement_list_terms(0);
					}
					break;
				}
				setState(563);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==ELSE) {
					{
					setState(562);
					else_tail();
					}
				}

				setState(565);
				match(END);
				}
				break;
			case 15:
				_localctx = new PrimaryBlockCase1Context(_localctx);
				enterOuterAlt(_localctx, 15);
				{
				setState(567);
				match(CASE);
				setState(569);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
				case 1:
					{
					setState(568);
					match(DOLLAR);
					}
					break;
				}
				setState(572);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
				case 1:
					{
					setState(571);
					statement_list_terms(0);
					}
					break;
				}
				setState(575); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(574);
					case_body();
					}
					}
					setState(577); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==ELSE || _la==WHEN );
				setState(579);
				match(END);
				}
				break;
			case 16:
				_localctx = new PrimaryBlockWhileContext(_localctx);
				enterOuterAlt(_localctx, 16);
				{
				setState(581);
				match(WHILE);
				setState(583);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(582);
					crlfs();
					}
				}

				setState(585);
				expr(0);
				setState(586);
				do_keyword();
				setState(588);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
				case 1:
					{
					setState(587);
					statement_list_terms(0);
					}
					break;
				}
				setState(590);
				match(END);
				}
				break;
			case 17:
				_localctx = new PrimaryBlockUntilContext(_localctx);
				enterOuterAlt(_localctx, 17);
				{
				setState(592);
				match(UNTIL);
				setState(594);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(593);
					crlfs();
					}
				}

				setState(596);
				expr(0);
				setState(597);
				do_keyword();
				setState(599);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
				case 1:
					{
					setState(598);
					statement_list_terms(0);
					}
					break;
				}
				setState(601);
				match(END);
				}
				break;
			case 18:
				_localctx = new PrimaryBlockForContext(_localctx);
				enterOuterAlt(_localctx, 18);
				{
				setState(603);
				match(FOR);
				setState(605);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(604);
					crlfs();
					}
				}

				setState(607);
				expr(0);
				setState(608);
				match(IN);
				setState(609);
				when_cond();
				setState(612);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case DO:
					{
					setState(610);
					match(DO);
					}
					break;
				case CRLF:
				case SL_COMMENT:
					{
					setState(611);
					crlfs();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(615);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
				case 1:
					{
					setState(614);
					statement_list_terms(0);
					}
					break;
				}
				setState(617);
				match(END);
				}
				break;
			case 19:
				_localctx = new PrimaryBlockClassDefContext(_localctx);
				enterOuterAlt(_localctx, 19);
				{
				setState(619);
				class_definition();
				}
				break;
			case 20:
				_localctx = new PrimaryBlockFunctionDefContext(_localctx);
				enterOuterAlt(_localctx, 20);
				{
				setState(620);
				function_definition();
				}
				break;
			case 21:
				_localctx = new PrimaryBlockModelDefContext(_localctx);
				enterOuterAlt(_localctx, 21);
				{
				setState(621);
				module_definition();
				}
				break;
			case 22:
				_localctx = new PrimaryFunctionCall0Context(_localctx);
				enterOuterAlt(_localctx, 22);
				{
				setState(622);
				function_name();
				setState(623);
				func_call_parameters();
				}
				break;
			case 23:
				_localctx = new PrimaryListHashContext(_localctx);
				enterOuterAlt(_localctx, 23);
				{
				setState(625);
				match(LEFT_PAREN);
				setState(627);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(626);
					crlfs();
					}
				}

				setState(629);
				hash_asso();
				setState(631);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
				case 1:
					{
					setState(630);
					crlfs();
					}
					break;
				}
				setState(640);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(633);
						match(COMMA);
						setState(635);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(634);
							crlfs();
							}
						}

						setState(637);
						hash_asso();
						}
						} 
					}
					setState(642);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
				}
				setState(644);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA) {
					{
					setState(643);
					match(COMMA);
					}
				}

				setState(647);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(646);
					crlfs();
					}
				}

				setState(649);
				match(RIGHT_PAREN);
				}
				break;
			case 24:
				_localctx = new PrimaryListExprContext(_localctx);
				enterOuterAlt(_localctx, 24);
				{
				setState(651);
				match(LEFT_SBRACKET);
				setState(653);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(652);
					crlfs();
					}
				}

				setState(655);
				expr(0);
				setState(657);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
				case 1:
					{
					setState(656);
					crlfs();
					}
					break;
				}
				setState(666);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(659);
						match(COMMA);
						setState(661);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==CRLF || _la==SL_COMMENT) {
							{
							setState(660);
							crlfs();
							}
						}

						setState(663);
						expr(0);
						}
						} 
					}
					setState(668);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
				}
				setState(670);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA) {
					{
					setState(669);
					match(COMMA);
					}
				}

				setState(673);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(672);
					crlfs();
					}
				}

				setState(675);
				match(RIGHT_SBRACKET);
				}
				break;
			case 25:
				_localctx = new PrimaryRangeContext(_localctx);
				enterOuterAlt(_localctx, 25);
				{
				setState(677);
				match(LEFT_RBRACKET);
				setState(678);
				expr(0);
				setState(679);
				_la = _input.LA(1);
				if ( !(_la==DOT3 || _la==DOT2) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(681);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -576814814342135840L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 225159087385132983L) != 0)) {
					{
					setState(680);
					expr(0);
					}
				}

				setState(683);
				match(RIGHT_RBRACKET);
				}
				break;
			case 26:
				_localctx = new PrimaryVarPathContext(_localctx);
				enterOuterAlt(_localctx, 26);
				{
				setState(685);
				variable_path(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Func_call_parametersContext extends ParserRuleContext {
		public TerminalNode LEFT_RBRACKET() { return getToken(RubyParser.LEFT_RBRACKET, 0); }
		public List<Function_call_paramContext> function_call_param() {
			return getRuleContexts(Function_call_paramContext.class);
		}
		public Function_call_paramContext function_call_param(int i) {
			return getRuleContext(Function_call_paramContext.class,i);
		}
		public TerminalNode RIGHT_RBRACKET() { return getToken(RubyParser.RIGHT_RBRACKET, 0); }
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public Func_call_parametersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_func_call_parameters; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunc_call_parameters(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Func_call_parametersContext func_call_parameters() throws RecognitionException {
		Func_call_parametersContext _localctx = new Func_call_parametersContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_func_call_parameters);
		int _la;
		try {
			setState(713);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(688);
				match(LEFT_RBRACKET);
				setState(690);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(689);
					crlfs();
					}
				}

				setState(692);
				function_call_param();
				setState(700);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(693);
					match(COMMA);
					setState(695);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==CRLF || _la==SL_COMMENT) {
						{
						setState(694);
						crlfs();
						}
					}

					setState(697);
					function_call_param();
					}
					}
					setState(702);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(704);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(703);
					crlfs();
					}
				}

				setState(706);
				match(RIGHT_RBRACKET);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(708);
				match(LEFT_RBRACKET);
				setState(710);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(709);
					crlfs();
					}
				}

				setState(712);
				match(RIGHT_RBRACKET);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Func_call_parameters_no_bracketContext extends ParserRuleContext {
		public List<Function_call_paramContext> function_call_param() {
			return getRuleContexts(Function_call_paramContext.class);
		}
		public Function_call_paramContext function_call_param(int i) {
			return getRuleContext(Function_call_paramContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public Func_call_parameters_no_bracketContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_func_call_parameters_no_bracket; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitFunc_call_parameters_no_bracket(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Func_call_parameters_no_bracketContext func_call_parameters_no_bracket() throws RecognitionException {
		Func_call_parameters_no_bracketContext _localctx = new Func_call_parameters_no_bracketContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_func_call_parameters_no_bracket);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(715);
			function_call_param();
			setState(723);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(716);
					match(COMMA);
					setState(718);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==CRLF || _la==SL_COMMENT) {
						{
						setState(717);
						crlfs();
						}
					}

					setState(720);
					function_call_param();
					}
					} 
				}
				setState(725);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rescure_paramContext extends ParserRuleContext {
		public Id_symbolContext id_symbol() {
			return getRuleContext(Id_symbolContext.class,0);
		}
		public Hash_assoContext hash_asso() {
			return getRuleContext(Hash_assoContext.class,0);
		}
		public TerminalNode ASSOC() { return getToken(RubyParser.ASSOC, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public Rescure_paramContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rescure_param; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitRescure_param(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Rescure_paramContext rescure_param() throws RecognitionException {
		Rescure_paramContext _localctx = new Rescure_paramContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_rescure_param);
		try {
			setState(730);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(726);
				id_symbol();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(727);
				hash_asso();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(728);
				match(ASSOC);
				setState(729);
				identifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Case_bodyContext extends ParserRuleContext {
		public TerminalNode WHEN() { return getToken(RubyParser.WHEN, 0); }
		public List<When_condContext> when_cond() {
			return getRuleContexts(When_condContext.class);
		}
		public When_condContext when_cond(int i) {
			return getRuleContext(When_condContext.class,i);
		}
		public Then_keywordContext then_keyword() {
			return getRuleContext(Then_keywordContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public Else_tailContext else_tail() {
			return getRuleContext(Else_tailContext.class,0);
		}
		public Case_bodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_case_body; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitCase_body(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Case_bodyContext case_body() throws RecognitionException {
		Case_bodyContext _localctx = new Case_bodyContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_case_body);
		try {
			int _alt;
			setState(745);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case WHEN:
				enterOuterAlt(_localctx, 1);
				{
				setState(732);
				match(WHEN);
				setState(733);
				when_cond();
				setState(738);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(734);
						match(COMMA);
						setState(735);
						when_cond();
						}
						} 
					}
					setState(740);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
				}
				setState(741);
				then_keyword();
				setState(742);
				statement_list_terms(0);
				}
				break;
			case ELSE:
				enterOuterAlt(_localctx, 2);
				{
				setState(744);
				else_tail();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class When_condContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public When_condContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_when_cond; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitWhen_cond(this);
			else return visitor.visitChildren(this);
		}
	}

	public final When_condContext when_cond() throws RecognitionException {
		When_condContext _localctx = new When_condContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_when_cond);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(747);
			expr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class If_tailContext extends ParserRuleContext {
		public TerminalNode ELSIF() { return getToken(RubyParser.ELSIF, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Then_keywordContext then_keyword() {
			return getRuleContext(Then_keywordContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Else_tailContext else_tail() {
			return getRuleContext(Else_tailContext.class,0);
		}
		public If_tailContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_if_tail; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitIf_tail(this);
			else return visitor.visitChildren(this);
		}
	}

	public final If_tailContext if_tail() throws RecognitionException {
		If_tailContext _localctx = new If_tailContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_if_tail);
		int _la;
		try {
			setState(758);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ELSIF:
				enterOuterAlt(_localctx, 1);
				{
				setState(749);
				match(ELSIF);
				setState(751);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CRLF || _la==SL_COMMENT) {
					{
					setState(750);
					crlfs();
					}
				}

				setState(753);
				expr(0);
				setState(754);
				then_keyword();
				setState(755);
				statement_list_terms(0);
				}
				break;
			case ELSE:
				enterOuterAlt(_localctx, 2);
				{
				setState(757);
				else_tail();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Else_tailContext extends ParserRuleContext {
		public TerminalNode ELSE() { return getToken(RubyParser.ELSE, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public CrlfsContext crlfs() {
			return getRuleContext(CrlfsContext.class,0);
		}
		public Else_tailContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_else_tail; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitElse_tail(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Else_tailContext else_tail() throws RecognitionException {
		Else_tailContext _localctx = new Else_tailContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_else_tail);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(760);
			match(ELSE);
			setState(762);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
			case 1:
				{
				setState(761);
				crlfs();
				}
				break;
			}
			setState(764);
			statement_list_terms(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Dot_refContext extends ParserRuleContext {
		public TerminalNode DOT() { return getToken(RubyParser.DOT, 0); }
		public TerminalNode ANDDOT() { return getToken(RubyParser.ANDDOT, 0); }
		public Dot_refContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dot_ref; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitDot_ref(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dot_refContext dot_ref() throws RecognitionException {
		Dot_refContext _localctx = new Dot_refContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_dot_ref);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(766);
			_la = _input.LA(1);
			if ( !(_la==ANDDOT || _la==DOT) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LogicalOperatorContext extends ParserRuleContext {
		public TerminalNode OR() { return getToken(RubyParser.OR, 0); }
		public TerminalNode AND() { return getToken(RubyParser.AND, 0); }
		public LogicalOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitLogicalOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicalOperatorContext logicalOperator() throws RecognitionException {
		LogicalOperatorContext _localctx = new LogicalOperatorContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_logicalOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(768);
			_la = _input.LA(1);
			if ( !(_la==AND || _la==OR) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EqualsOperatorContext extends ParserRuleContext {
		public TerminalNode EQUAL() { return getToken(RubyParser.EQUAL, 0); }
		public TerminalNode NOT_EQUAL() { return getToken(RubyParser.NOT_EQUAL, 0); }
		public TerminalNode EQUAL3() { return getToken(RubyParser.EQUAL3, 0); }
		public EqualsOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_equalsOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitEqualsOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EqualsOperatorContext equalsOperator() throws RecognitionException {
		EqualsOperatorContext _localctx = new EqualsOperatorContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_equalsOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(770);
			_la = _input.LA(1);
			if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 196609L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CompareOperatorContext extends ParserRuleContext {
		public TerminalNode LESS() { return getToken(RubyParser.LESS, 0); }
		public TerminalNode GREATER() { return getToken(RubyParser.GREATER, 0); }
		public TerminalNode LESS_EQUAL() { return getToken(RubyParser.LESS_EQUAL, 0); }
		public TerminalNode GREATER_EQUAL() { return getToken(RubyParser.GREATER_EQUAL, 0); }
		public CompareOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compareOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitCompareOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CompareOperatorContext compareOperator() throws RecognitionException {
		CompareOperatorContext _localctx = new CompareOperatorContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_compareOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(772);
			_la = _input.LA(1);
			if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 773L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BitOperatorContext extends ParserRuleContext {
		public TerminalNode BIT_SHL() { return getToken(RubyParser.BIT_SHL, 0); }
		public TerminalNode BIT_SHR() { return getToken(RubyParser.BIT_SHR, 0); }
		public TerminalNode BIT_AND() { return getToken(RubyParser.BIT_AND, 0); }
		public TerminalNode BIT_OR() { return getToken(RubyParser.BIT_OR, 0); }
		public TerminalNode BIT_XOR() { return getToken(RubyParser.BIT_XOR, 0); }
		public BitOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bitOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitBitOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BitOperatorContext bitOperator() throws RecognitionException {
		BitOperatorContext _localctx = new BitOperatorContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_bitOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(774);
			_la = _input.LA(1);
			if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & 37385811263489L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MathOperatorContext extends ParserRuleContext {
		public TerminalNode MUL() { return getToken(RubyParser.MUL, 0); }
		public TerminalNode DIV() { return getToken(RubyParser.DIV, 0); }
		public TerminalNode MOD() { return getToken(RubyParser.MOD, 0); }
		public TerminalNode PLUS() { return getToken(RubyParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(RubyParser.MINUS, 0); }
		public TerminalNode EXP() { return getToken(RubyParser.EXP, 0); }
		public MathOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mathOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitMathOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MathOperatorContext mathOperator() throws RecognitionException {
		MathOperatorContext _localctx = new MathOperatorContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_mathOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(776);
			_la = _input.LA(1);
			if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & 67115015L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AssignOperatorContext extends ParserRuleContext {
		public TerminalNode PLUS_ASSIGN() { return getToken(RubyParser.PLUS_ASSIGN, 0); }
		public TerminalNode MINUS_ASSIGN() { return getToken(RubyParser.MINUS_ASSIGN, 0); }
		public TerminalNode MUL_ASSIGN() { return getToken(RubyParser.MUL_ASSIGN, 0); }
		public TerminalNode DIV_ASSIGN() { return getToken(RubyParser.DIV_ASSIGN, 0); }
		public TerminalNode MOD_ASSIGN() { return getToken(RubyParser.MOD_ASSIGN, 0); }
		public TerminalNode EXP_ASSIGN() { return getToken(RubyParser.EXP_ASSIGN, 0); }
		public TerminalNode BIT_OR_ASSIGN() { return getToken(RubyParser.BIT_OR_ASSIGN, 0); }
		public TerminalNode BIT_AND_ASSIGN() { return getToken(RubyParser.BIT_AND_ASSIGN, 0); }
		public TerminalNode OR_ASSIGN() { return getToken(RubyParser.OR_ASSIGN, 0); }
		public TerminalNode AND_ASSIGN() { return getToken(RubyParser.AND_ASSIGN, 0); }
		public TerminalNode BIT_XOR_ASSIGN() { return getToken(RubyParser.BIT_XOR_ASSIGN, 0); }
		public TerminalNode BIT_NOT_ASSIGN() { return getToken(RubyParser.BIT_NOT_ASSIGN, 0); }
		public TerminalNode BIT_SHL_ASSIGN() { return getToken(RubyParser.BIT_SHL_ASSIGN, 0); }
		public TerminalNode BIT_SHR_ASSIGN() { return getToken(RubyParser.BIT_SHR_ASSIGN, 0); }
		public AssignOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitAssignOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AssignOperatorContext assignOperator() throws RecognitionException {
		AssignOperatorContext _localctx = new AssignOperatorContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_assignOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(778);
			_la = _input.LA(1);
			if ( !(((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1477793024050331L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NotContext extends ParserRuleContext {
		public TerminalNode NOT() { return getToken(RubyParser.NOT, 0); }
		public TerminalNode SIGH() { return getToken(RubyParser.SIGH, 0); }
		public NotContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_not; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitNot(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NotContext not() throws RecognitionException {
		NotContext _localctx = new NotContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_not);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(780);
			_la = _input.LA(1);
			if ( !(_la==NOT || _la==SIGH) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BlockContext extends ParserRuleContext {
		public TerminalNode LEFT_PAREN() { return getToken(RubyParser.LEFT_PAREN, 0); }
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(RubyParser.RIGHT_PAREN, 0); }
		public List<CrlfsContext> crlfs() {
			return getRuleContexts(CrlfsContext.class);
		}
		public CrlfsContext crlfs(int i) {
			return getRuleContext(CrlfsContext.class,i);
		}
		public Block_paramsContext block_params() {
			return getRuleContext(Block_paramsContext.class,0);
		}
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(782);
			match(LEFT_PAREN);
			setState(784);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
			case 1:
				{
				setState(783);
				crlfs();
				}
				break;
			}
			setState(787);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
			case 1:
				{
				setState(786);
				block_params();
				}
				break;
			}
			setState(790);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
			case 1:
				{
				setState(789);
				crlfs();
				}
				break;
			}
			setState(792);
			statement_list_terms(0);
			setState(794);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==CRLF || _la==SL_COMMENT) {
				{
				setState(793);
				crlfs();
				}
			}

			setState(796);
			match(RIGHT_PAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Block_paramsContext extends ParserRuleContext {
		public List<TerminalNode> BIT_OR() { return getTokens(RubyParser.BIT_OR); }
		public TerminalNode BIT_OR(int i) {
			return getToken(RubyParser.BIT_OR, i);
		}
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(RubyParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(RubyParser.COMMA, i);
		}
		public Block_paramsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block_params; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitBlock_params(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Block_paramsContext block_params() throws RecognitionException {
		Block_paramsContext _localctx = new Block_paramsContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_block_params);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(798);
			match(BIT_OR);
			setState(799);
			expr(0);
			setState(804);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(800);
				match(COMMA);
				setState(801);
				expr(0);
				}
				}
				setState(806);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(807);
			match(BIT_OR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Id_symbolContext extends ParserRuleContext {
		public CpathContext cpath() {
			return getRuleContext(CpathContext.class,0);
		}
		public TerminalNode COLON() { return getToken(RubyParser.COLON, 0); }
		public Id_symbolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_id_symbol; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitId_symbol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Id_symbolContext id_symbol() throws RecognitionException {
		Id_symbolContext _localctx = new Id_symbolContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_id_symbol);
		try {
			setState(812);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case BREAK:
			case NEXT:
			case NIL:
			case REDO:
			case RETRY:
			case SELF:
			case SUPER:
			case DollarSpecial:
			case DOLLAR:
			case AT:
			case LEFT_PAREN:
			case LEFT_SBRACKET:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(809);
				cpath();
				}
				break;
			case COLON:
				enterOuterAlt(_localctx, 2);
				{
				setState(810);
				match(COLON);
				setState(811);
				cpath();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SymbolContext extends ParserRuleContext {
		public List<TerminalNode> COLON() { return getTokens(RubyParser.COLON); }
		public TerminalNode COLON(int i) {
			return getToken(RubyParser.COLON, i);
		}
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public StringContext string() {
			return getRuleContext(StringContext.class,0);
		}
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public SymbolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_symbol; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitSymbol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SymbolContext symbol() throws RecognitionException {
		SymbolContext _localctx = new SymbolContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_symbol);
		try {
			setState(821);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(814);
				match(COLON);
				setState(815);
				identifier();
				setState(816);
				match(COLON);
				setState(817);
				string();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(819);
				match(COLON);
				setState(820);
				function_name();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Hash_assoContext extends ParserRuleContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode ASSOC() { return getToken(RubyParser.ASSOC, 0); }
		public TerminalNode COLON() { return getToken(RubyParser.COLON, 0); }
		public Hash_assoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_hash_asso; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitHash_asso(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Hash_assoContext hash_asso() throws RecognitionException {
		Hash_assoContext _localctx = new Hash_assoContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_hash_asso);
		try {
			setState(831);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(823);
				expr(0);
				setState(824);
				match(ASSOC);
				setState(825);
				expr(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(827);
				expr(0);
				setState(828);
				match(COLON);
				setState(829);
				expr(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Variable_pathContext extends ParserRuleContext {
		public Variable_pathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variable_path; }
	 
		public Variable_pathContext() { }
		public void copyFrom(Variable_pathContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarPathLiteralContext extends Variable_pathContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public VarPathLiteralContext(Variable_pathContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitVarPathLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarPathIdContext extends Variable_pathContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public VarPathIdContext(Variable_pathContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitVarPathId(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarPathGlobalPrefixContext extends Variable_pathContext {
		public TerminalNode COLON2() { return getToken(RubyParser.COLON2, 0); }
		public Variable_pathContext variable_path() {
			return getRuleContext(Variable_pathContext.class,0);
		}
		public VarPathGlobalPrefixContext(Variable_pathContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitVarPathGlobalPrefix(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarPathJoinContext extends Variable_pathContext {
		public Variable_pathContext variable_path() {
			return getRuleContext(Variable_pathContext.class,0);
		}
		public TerminalNode COLON2() { return getToken(RubyParser.COLON2, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public VarPathJoinContext(Variable_pathContext ctx) { copyFrom(ctx); }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitVarPathJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Variable_pathContext variable_path() throws RecognitionException {
		return variable_path(0);
	}

	private Variable_pathContext variable_path(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Variable_pathContext _localctx = new Variable_pathContext(_ctx, _parentState);
		Variable_pathContext _prevctx = _localctx;
		int _startState = 86;
		enterRecursionRule(_localctx, 86, RULE_variable_path, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(838);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
			case 1:
				{
				_localctx = new VarPathIdContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(834);
				identifier();
				}
				break;
			case 2:
				{
				_localctx = new VarPathLiteralContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(835);
				literal();
				}
				break;
			case 3:
				{
				_localctx = new VarPathGlobalPrefixContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(836);
				match(COLON2);
				setState(837);
				variable_path(1);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(848);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,114,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new VarPathJoinContext(new Variable_pathContext(_parentctx, _parentState));
					pushNewRecursionContext(_localctx, _startState, RULE_variable_path);
					setState(840);
					if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
					setState(841);
					match(COLON2);
					setState(844);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
					case 1:
						{
						setState(842);
						identifier();
						}
						break;
					case 2:
						{
						setState(843);
						literal();
						}
						break;
					}
					}
					} 
				}
				setState(850);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,114,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CpathContext extends ParserRuleContext {
		public List<IdentifierContext> identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public List<TerminalNode> COLON2() { return getTokens(RubyParser.COLON2); }
		public TerminalNode COLON2(int i) {
			return getToken(RubyParser.COLON2, i);
		}
		public List<TerminalNode> DOT() { return getTokens(RubyParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(RubyParser.DOT, i);
		}
		public CpathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cpath; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitCpath(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CpathContext cpath() throws RecognitionException {
		CpathContext _localctx = new CpathContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_cpath);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(851);
			identifier();
			setState(856);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(852);
					_la = _input.LA(1);
					if ( !(_la==DOT || _la==COLON2) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(853);
					identifier();
					}
					} 
				}
				setState(858);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LiteralContext extends ParserRuleContext {
		public TerminalNode Float() { return getToken(RubyParser.Float, 0); }
		public SyntaxErrorContext syntaxError() {
			return getRuleContext(SyntaxErrorContext.class,0);
		}
		public StringContext string() {
			return getRuleContext(StringContext.class,0);
		}
		public TerminalNode Integer() { return getToken(RubyParser.Integer, 0); }
		public TerminalNode TRUE() { return getToken(RubyParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(RubyParser.FALSE, 0); }
		public TerminalNode NIL() { return getToken(RubyParser.NIL, 0); }
		public TerminalNode DOT() { return getToken(RubyParser.DOT, 0); }
		public TerminalNode ShellCommand() { return getToken(RubyParser.ShellCommand, 0); }
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_literal);
		int _la;
		try {
			setState(868);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(859);
				match(Float);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(860);
				syntaxError();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(861);
				string();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(862);
				match(Integer);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(863);
				_la = _input.LA(1);
				if ( !(_la==FALSE || _la==TRUE) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(864);
				match(NIL);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(865);
				match(Float);
				setState(866);
				match(DOT);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(867);
				match(ShellCommand);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdentifierContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(RubyParser.Identifier, 0); }
		public GlobalVarContext globalVar() {
			return getRuleContext(GlobalVarContext.class,0);
		}
		public ClassVarContext classVar() {
			return getRuleContext(ClassVarContext.class,0);
		}
		public InstanceVarContext instanceVar() {
			return getRuleContext(InstanceVarContext.class,0);
		}
		public IdArgContext idArg() {
			return getRuleContext(IdArgContext.class,0);
		}
		public NextContext next() {
			return getRuleContext(NextContext.class,0);
		}
		public TerminalNode REDO() { return getToken(RubyParser.REDO, 0); }
		public TerminalNode RETRY() { return getToken(RubyParser.RETRY, 0); }
		public TerminalNode BREAK() { return getToken(RubyParser.BREAK, 0); }
		public TerminalNode SELF() { return getToken(RubyParser.SELF, 0); }
		public TerminalNode SUPER() { return getToken(RubyParser.SUPER, 0); }
		public TerminalNode NIL() { return getToken(RubyParser.NIL, 0); }
		public EmptyContext empty() {
			return getRuleContext(EmptyContext.class,0);
		}
		public IdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitIdentifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdentifierContext identifier() throws RecognitionException {
		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_identifier);
		try {
			setState(883);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(870);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(871);
				globalVar();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(872);
				classVar();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(873);
				instanceVar();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(874);
				idArg();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(875);
				next();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(876);
				match(REDO);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(877);
				match(RETRY);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(878);
				match(BREAK);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(879);
				match(SELF);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(880);
				match(SUPER);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(881);
				match(NIL);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(882);
				empty();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NextContext extends ParserRuleContext {
		public TerminalNode NEXT() { return getToken(RubyParser.NEXT, 0); }
		public NextContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_next; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitNext(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NextContext next() throws RecognitionException {
		NextContext _localctx = new NextContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_next);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(885);
			match(NEXT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EmptyContext extends ParserRuleContext {
		public TerminalNode LEFT_PAREN() { return getToken(RubyParser.LEFT_PAREN, 0); }
		public TerminalNode RIGHT_PAREN() { return getToken(RubyParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_SBRACKET() { return getToken(RubyParser.LEFT_SBRACKET, 0); }
		public TerminalNode RIGHT_SBRACKET() { return getToken(RubyParser.RIGHT_SBRACKET, 0); }
		public EmptyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_empty; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitEmpty(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EmptyContext empty() throws RecognitionException {
		EmptyContext _localctx = new EmptyContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_empty);
		try {
			setState(891);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LEFT_PAREN:
				enterOuterAlt(_localctx, 1);
				{
				setState(887);
				match(LEFT_PAREN);
				setState(888);
				match(RIGHT_PAREN);
				}
				break;
			case LEFT_SBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(889);
				match(LEFT_SBRACKET);
				setState(890);
				match(RIGHT_SBRACKET);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class GlobalVarContext extends ParserRuleContext {
		public TerminalNode DOLLAR() { return getToken(RubyParser.DOLLAR, 0); }
		public TerminalNode Identifier() { return getToken(RubyParser.Identifier, 0); }
		public GlobalVarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_globalVar; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitGlobalVar(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GlobalVarContext globalVar() throws RecognitionException {
		GlobalVarContext _localctx = new GlobalVarContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_globalVar);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(893);
			match(DOLLAR);
			setState(894);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassVarContext extends ParserRuleContext {
		public List<TerminalNode> AT() { return getTokens(RubyParser.AT); }
		public TerminalNode AT(int i) {
			return getToken(RubyParser.AT, i);
		}
		public TerminalNode Identifier() { return getToken(RubyParser.Identifier, 0); }
		public ClassVarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classVar; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitClassVar(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassVarContext classVar() throws RecognitionException {
		ClassVarContext _localctx = new ClassVarContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_classVar);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(896);
			match(AT);
			setState(897);
			match(AT);
			setState(898);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InstanceVarContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(RubyParser.AT, 0); }
		public TerminalNode Identifier() { return getToken(RubyParser.Identifier, 0); }
		public InstanceVarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_instanceVar; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitInstanceVar(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InstanceVarContext instanceVar() throws RecognitionException {
		InstanceVarContext _localctx = new InstanceVarContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_instanceVar);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(900);
			match(AT);
			setState(901);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdArgContext extends ParserRuleContext {
		public TerminalNode DOLLAR() { return getToken(RubyParser.DOLLAR, 0); }
		public TerminalNode Integer() { return getToken(RubyParser.Integer, 0); }
		public TerminalNode DollarSpecial() { return getToken(RubyParser.DollarSpecial, 0); }
		public IdArgContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_idArg; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitIdArg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdArgContext idArg() throws RecognitionException {
		IdArgContext _localctx = new IdArgContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_idArg);
		try {
			setState(906);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case DOLLAR:
				enterOuterAlt(_localctx, 1);
				{
				setState(903);
				match(DOLLAR);
				setState(904);
				match(Integer);
				}
				break;
			case DollarSpecial:
				enterOuterAlt(_localctx, 2);
				{
				setState(905);
				match(DollarSpecial);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Do_keywordContext extends ParserRuleContext {
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public TerminalNode DO() { return getToken(RubyParser.DO, 0); }
		public TerminalNode SEMICOLON() { return getToken(RubyParser.SEMICOLON, 0); }
		public Do_keywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_do_keyword; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitDo_keyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Do_keywordContext do_keyword() throws RecognitionException {
		Do_keywordContext _localctx = new Do_keywordContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_do_keyword);
		int _la;
		try {
			setState(911);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(908);
				_la = _input.LA(1);
				if ( !(_la==DO || _la==SEMICOLON) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(909);
				terms();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(910);
				terms();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Then_keywordContext extends ParserRuleContext {
		public TerminalNode THEN() { return getToken(RubyParser.THEN, 0); }
		public TerminalNode SEMICOLON() { return getToken(RubyParser.SEMICOLON, 0); }
		public TermsContext terms() {
			return getRuleContext(TermsContext.class,0);
		}
		public Then_keywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_then_keyword; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitThen_keyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Then_keywordContext then_keyword() throws RecognitionException {
		Then_keywordContext _localctx = new Then_keywordContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_then_keyword);
		int _la;
		try {
			setState(918);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(913);
				_la = _input.LA(1);
				if ( !(_la==THEN || _la==SEMICOLON) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(915);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
				case 1:
					{
					setState(914);
					terms();
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(917);
				terms();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StringContext extends ParserRuleContext {
		public List<TerminalNode> String() { return getTokens(RubyParser.String); }
		public TerminalNode String(int i) {
			return getToken(RubyParser.String, i);
		}
		public StringContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_string; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitString(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StringContext string() throws RecognitionException {
		StringContext _localctx = new StringContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_string);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(921); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(920);
					match(String);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(923); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,123,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnsureContext extends ParserRuleContext {
		public TerminalNode ENSURE() { return getToken(RubyParser.ENSURE, 0); }
		public EnsureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ensure; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitEnsure(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnsureContext ensure() throws RecognitionException {
		EnsureContext _localctx = new EnsureContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_ensure);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(925);
			match(ENSURE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CrlfsContext extends ParserRuleContext {
		public List<TerminalNode> SL_COMMENT() { return getTokens(RubyParser.SL_COMMENT); }
		public TerminalNode SL_COMMENT(int i) {
			return getToken(RubyParser.SL_COMMENT, i);
		}
		public List<TerminalNode> CRLF() { return getTokens(RubyParser.CRLF); }
		public TerminalNode CRLF(int i) {
			return getToken(RubyParser.CRLF, i);
		}
		public CrlfsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_crlfs; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitCrlfs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CrlfsContext crlfs() throws RecognitionException {
		CrlfsContext _localctx = new CrlfsContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_crlfs);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(928); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(927);
					_la = _input.LA(1);
					if ( !(_la==CRLF || _la==SL_COMMENT) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(930); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,124,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TermsContext extends ParserRuleContext {
		public List<TermContext> term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public TermsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_terms; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitTerms(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermsContext terms() throws RecognitionException {
		TermsContext _localctx = new TermsContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_terms);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(935);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(932);
					term();
					}
					} 
				}
				setState(937);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TermContext extends ParserRuleContext {
		public TerminalNode SEMICOLON() { return getToken(RubyParser.SEMICOLON, 0); }
		public TerminalNode CRLF() { return getToken(RubyParser.CRLF, 0); }
		public TerminalNode SL_COMMENT() { return getToken(RubyParser.SL_COMMENT, 0); }
		public TermContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_term; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitTerm(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermContext term() throws RecognitionException {
		TermContext _localctx = new TermContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_term);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(938);
			_la = _input.LA(1);
			if ( !(((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & 288230410511450113L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RescuestatementContext extends ParserRuleContext {
		public TerminalNode RESCUE() { return getToken(RubyParser.RESCUE, 0); }
		public Rescure_paramContext rescure_param() {
			return getRuleContext(Rescure_paramContext.class,0);
		}
		public Statement_list_termsContext statement_list_terms() {
			return getRuleContext(Statement_list_termsContext.class,0);
		}
		public Else_tailContext else_tail() {
			return getRuleContext(Else_tailContext.class,0);
		}
		public RescuestatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rescuestatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitRescuestatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RescuestatementContext rescuestatement() throws RecognitionException {
		RescuestatementContext _localctx = new RescuestatementContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_rescuestatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(940);
			match(RESCUE);
			setState(942);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
			case 1:
				{
				setState(941);
				rescure_param();
				}
				break;
			}
			setState(945);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
			case 1:
				{
				setState(944);
				statement_list_terms(0);
				}
				break;
			}
			setState(948);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
			case 1:
				{
				setState(947);
				else_tail();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrintContext extends ParserRuleContext {
		public TerminalNode PRINT() { return getToken(RubyParser.PRINT, 0); }
		public TerminalNode PUTS() { return getToken(RubyParser.PUTS, 0); }
		public TerminalNode P() { return getToken(RubyParser.P, 0); }
		public TerminalNode PRINTF() { return getToken(RubyParser.PRINTF, 0); }
		public PrintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_print; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitPrint(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrintContext print() throws RecognitionException {
		PrintContext _localctx = new PrintContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_print);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(950);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 15360L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IncluContext extends ParserRuleContext {
		public TerminalNode INCLUDE() { return getToken(RubyParser.INCLUDE, 0); }
		public IncluContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inclu; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitInclu(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IncluContext inclu() throws RecognitionException {
		IncluContext _localctx = new IncluContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_inclu);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(952);
			match(INCLUDE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ModifierContext extends ParserRuleContext {
		public TerminalNode PUBLIC() { return getToken(RubyParser.PUBLIC, 0); }
		public TerminalNode PRIVATE() { return getToken(RubyParser.PRIVATE, 0); }
		public TerminalNode PROTECTED() { return getToken(RubyParser.PROTECTED, 0); }
		public ModifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_modifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitModifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ModifierContext modifier() throws RecognitionException {
		ModifierContext _localctx = new ModifierContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_modifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(954);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 448L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SyntaxErrorContext extends ParserRuleContext {
		public TerminalNode SYNTAXERROR() { return getToken(RubyParser.SYNTAXERROR, 0); }
		public SyntaxErrorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_syntaxError; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitSyntaxError(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SyntaxErrorContext syntaxError() throws RecognitionException {
		SyntaxErrorContext _localctx = new SyntaxErrorContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_syntaxError);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(956);
			match(SYNTAXERROR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RetryContext extends ParserRuleContext {
		public TerminalNode RETRY() { return getToken(RubyParser.RETRY, 0); }
		public RetryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_retry; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof RubyParserVisitor ) return ((RubyParserVisitor<? extends T>)visitor).visitRetry(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RetryContext retry() throws RecognitionException {
		RetryContext _localctx = new RetryContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_retry);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(958);
			match(RETRY);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 1:
			return statement_list_terms_sempred((Statement_list_termsContext)_localctx, predIndex);
		case 20:
			return expr_sempred((ExprContext)_localctx, predIndex);
		case 43:
			return variable_path_sempred((Variable_pathContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean statement_list_terms_sempred(Statement_list_termsContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 2);
		}
		return true;
	}
	private boolean expr_sempred(ExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 1:
			return precpred(_ctx, 28);
		case 2:
			return precpred(_ctx, 27);
		case 3:
			return precpred(_ctx, 23);
		case 4:
			return precpred(_ctx, 17);
		case 5:
			return precpred(_ctx, 16);
		case 6:
			return precpred(_ctx, 15);
		case 7:
			return precpred(_ctx, 14);
		case 8:
			return precpred(_ctx, 12);
		case 9:
			return precpred(_ctx, 11);
		case 10:
			return precpred(_ctx, 10);
		case 11:
			return precpred(_ctx, 9);
		case 12:
			return precpred(_ctx, 8);
		case 13:
			return precpred(_ctx, 22);
		case 14:
			return precpred(_ctx, 20);
		case 15:
			return precpred(_ctx, 18);
		case 16:
			return precpred(_ctx, 7);
		case 17:
			return precpred(_ctx, 6);
		case 18:
			return precpred(_ctx, 5);
		case 19:
			return precpred(_ctx, 3);
		}
		return true;
	}
	private boolean variable_path_sempred(Variable_pathContext _localctx, int predIndex) {
		switch (predIndex) {
		case 20:
			return precpred(_ctx, 2);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001\u0084\u03c1\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
		"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
		"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
		"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
		"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
		"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
		"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
		"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
		"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
		"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
		"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
		"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
		"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
		",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
		"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
		"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
		";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
		"@\u0002A\u0007A\u0001\u0000\u0003\u0000\u0086\b\u0000\u0001\u0000\u0001"+
		"\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003"+
		"\u0001\u008f\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0005"+
		"\u0001\u0095\b\u0001\n\u0001\f\u0001\u0098\t\u0001\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0005\u0002\u009d\b\u0002\n\u0002\f\u0002\u00a0\t\u0002\u0001"+
		"\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
		"\u0003\u0001\u0003\u0003\u0003\u00aa\b\u0003\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0005\u0004\u00b0\b\u0004\n\u0004\f\u0004\u00b3\t\u0004"+
		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+
		"\u0003\u0006\u00bb\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0004\u0007\u00c1\b\u0007\u000b\u0007\f\u0007\u00c2\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001"+
		"\n\u0001\n\u0003\n\u00d2\b\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0003"+
		"\u000b\u00d8\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001"+
		"\f\u0001\r\u0001\r\u0001\r\u0003\r\u00e3\b\r\u0001\r\u0001\r\u0001\r\u0003"+
		"\r\u00e8\b\r\u0001\u000e\u0001\u000e\u0003\u000e\u00ec\b\u000e\u0001\u000e"+
		"\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u00f3\b\u000f"+
		"\u0001\u000f\u0003\u000f\u00f6\b\u000f\u0001\u000f\u0001\u000f\u0001\u0010"+
		"\u0001\u0010\u0003\u0010\u00fc\b\u0010\u0001\u0010\u0001\u0010\u0001\u0010"+
		"\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010"+
		"\u0003\u0010\u0107\b\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+
		"\u0003\u0011\u010d\b\u0011\u0001\u0011\u0005\u0011\u0110\b\u0011\n\u0011"+
		"\f\u0011\u0113\t\u0011\u0003\u0011\u0115\b\u0011\u0001\u0011\u0001\u0011"+
		"\u0001\u0011\u0001\u0011\u0003\u0011\u011b\b\u0011\u0001\u0011\u0005\u0011"+
		"\u011e\b\u0011\n\u0011\f\u0011\u0121\t\u0011\u0003\u0011\u0123\b\u0011"+
		"\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+
		"\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+
		"\u0003\u0012\u0131\b\u0012\u0001\u0013\u0001\u0013\u0003\u0013\u0135\b"+
		"\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0145\b\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u014b\b\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0153"+
		"\b\u0014\u0001\u0014\u0003\u0014\u0156\b\u0014\u0003\u0014\u0158\b\u0014"+
		"\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u015d\b\u0014\u0001\u0014"+
		"\u0003\u0014\u0160\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+
		"\u0001\u0014\u0003\u0014\u0167\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+
		"\u0001\u0014\u0003\u0014\u016d\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+
		"\u0001\u0014\u0003\u0014\u0173\b\u0014\u0001\u0014\u0003\u0014\u0176\b"+
		"\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u017a\b\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0003\u0014\u018a\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0003\u0014\u0191\b\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0198\b\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u019f\b\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003"+
		"\u0014\u01b3\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u01c2\b\u0014\u0005\u0014\u01c4"+
		"\b\u0014\n\u0014\f\u0014\u01c7\t\u0014\u0001\u0015\u0001\u0015\u0003\u0015"+
		"\u01cb\b\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u01d0\b"+
		"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u01d5\b\u0015\u0001"+
		"\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u01da\b\u0015\u0001\u0015\u0001"+
		"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u01e1\b\u0015\u0001"+
		"\u0015\u0003\u0015\u01e4\b\u0015\u0001\u0015\u0003\u0015\u01e7\b\u0015"+
		"\u0001\u0015\u0003\u0015\u01ea\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0003\u0016\u01f7\b\u0016\u0001\u0016\u0001\u0016"+
		"\u0003\u0016\u01fb\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0003\u0016\u0201\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
		"\u0206\b\u0016\u0001\u0016\u0003\u0016\u0209\b\u0016\u0001\u0016\u0003"+
		"\u0016\u020c\b\u0016\u0001\u0016\u0003\u0016\u020f\b\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u0215\b\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0003\u0016\u021a\b\u0016\u0001\u0016\u0005\u0016"+
		"\u021d\b\u0016\n\u0016\f\u0016\u0220\t\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0001\u0016\u0003\u0016\u022c\b\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0003\u0016\u0231\b\u0016\u0001\u0016\u0003\u0016\u0234\b\u0016"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u023a\b\u0016"+
		"\u0001\u0016\u0003\u0016\u023d\b\u0016\u0001\u0016\u0004\u0016\u0240\b"+
		"\u0016\u000b\u0016\f\u0016\u0241\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0003\u0016\u0248\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003"+
		"\u0016\u024d\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003"+
		"\u0016\u0253\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u0258"+
		"\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u025e"+
		"\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003"+
		"\u0016\u0265\b\u0016\u0001\u0016\u0003\u0016\u0268\b\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u0274\b\u0016\u0001\u0016"+
		"\u0001\u0016\u0003\u0016\u0278\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
		"\u027c\b\u0016\u0001\u0016\u0005\u0016\u027f\b\u0016\n\u0016\f\u0016\u0282"+
		"\t\u0016\u0001\u0016\u0003\u0016\u0285\b\u0016\u0001\u0016\u0003\u0016"+
		"\u0288\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
		"\u028e\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u0292\b\u0016\u0001"+
		"\u0016\u0001\u0016\u0003\u0016\u0296\b\u0016\u0001\u0016\u0005\u0016\u0299"+
		"\b\u0016\n\u0016\f\u0016\u029c\t\u0016\u0001\u0016\u0003\u0016\u029f\b"+
		"\u0016\u0001\u0016\u0003\u0016\u02a2\b\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02aa\b\u0016\u0001"+
		"\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02af\b\u0016\u0001\u0017\u0001"+
		"\u0017\u0003\u0017\u02b3\b\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0003"+
		"\u0017\u02b8\b\u0017\u0001\u0017\u0005\u0017\u02bb\b\u0017\n\u0017\f\u0017"+
		"\u02be\t\u0017\u0001\u0017\u0003\u0017\u02c1\b\u0017\u0001\u0017\u0001"+
		"\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u02c7\b\u0017\u0001\u0017\u0003"+
		"\u0017\u02ca\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u02cf"+
		"\b\u0018\u0001\u0018\u0005\u0018\u02d2\b\u0018\n\u0018\f\u0018\u02d5\t"+
		"\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u02db"+
		"\b\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0005\u001a\u02e1"+
		"\b\u001a\n\u001a\f\u001a\u02e4\t\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
		"\u0001\u001a\u0003\u001a\u02ea\b\u001a\u0001\u001b\u0001\u001b\u0001\u001c"+
		"\u0001\u001c\u0003\u001c\u02f0\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+
		"\u0001\u001c\u0001\u001c\u0003\u001c\u02f7\b\u001c\u0001\u001d\u0001\u001d"+
		"\u0003\u001d\u02fb\b\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e"+
		"\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001"+
		"#\u0001#\u0001$\u0001$\u0001%\u0001%\u0001&\u0001&\u0003&\u0311\b&\u0001"+
		"&\u0003&\u0314\b&\u0001&\u0003&\u0317\b&\u0001&\u0001&\u0003&\u031b\b"+
		"&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0005\'\u0323\b\'\n\'"+
		"\f\'\u0326\t\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0003(\u032d\b(\u0001"+
		")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0003)\u0336\b)\u0001*\u0001"+
		"*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u0340\b*\u0001+\u0001"+
		"+\u0001+\u0001+\u0001+\u0003+\u0347\b+\u0001+\u0001+\u0001+\u0001+\u0003"+
		"+\u034d\b+\u0005+\u034f\b+\n+\f+\u0352\t+\u0001,\u0001,\u0001,\u0005,"+
		"\u0357\b,\n,\f,\u035a\t,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001"+
		"-\u0001-\u0001-\u0003-\u0365\b-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+
		".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0003.\u0374\b.\u0001"+
		"/\u0001/\u00010\u00010\u00010\u00010\u00030\u037c\b0\u00011\u00011\u0001"+
		"1\u00012\u00012\u00012\u00012\u00013\u00013\u00013\u00014\u00014\u0001"+
		"4\u00034\u038b\b4\u00015\u00015\u00015\u00035\u0390\b5\u00016\u00016\u0003"+
		"6\u0394\b6\u00016\u00036\u0397\b6\u00017\u00047\u039a\b7\u000b7\f7\u039b"+
		"\u00018\u00018\u00019\u00049\u03a1\b9\u000b9\f9\u03a2\u0001:\u0005:\u03a6"+
		"\b:\n:\f:\u03a9\t:\u0001;\u0001;\u0001<\u0001<\u0003<\u03af\b<\u0001<"+
		"\u0003<\u03b2\b<\u0001<\u0003<\u03b5\b<\u0001=\u0001=\u0001>\u0001>\u0001"+
		"?\u0001?\u0001@\u0001@\u0001A\u0001A\u0001A\u0000\u0003\u0002(VB\u0000"+
		"\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c"+
		"\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0000"+
		"\u0016\u0001\u0000\u000e\u0010\u0003\u0000YY[[hh\u0003\u0000>@GGJJ\u0002"+
		"\u0000YY[[\u0001\u0000>?\u0001\u0000TU\u0002\u0000FFVV\u0001\u0000<=\u0002"+
		"\u0000ZZjk\u0003\u0000eeggmn\u0005\u0000GGccffpptt\u0003\u0000>@IJXX\n"+
		"\u0000ABDEHHKKWW`bddooqqss\u0002\u0000&&[[\u0002\u0000VV]]\u0002\u0000"+
		"\u001f\u001f//\u0002\u0000\u0019\u0019^^\u0002\u0000..^^\u0002\u0000;"+
		";uu\u0003\u0000;;^^uu\u0001\u0000\n\r\u0001\u0000\u0006\b\u0454\u0000"+
		"\u0085\u0001\u0000\u0000\u0000\u0002\u008e\u0001\u0000\u0000\u0000\u0004"+
		"\u009e\u0001\u0000\u0000\u0000\u0006\u00a9\u0001\u0000\u0000\u0000\b\u00ab"+
		"\u0001\u0000\u0000\u0000\n\u00b4\u0001\u0000\u0000\u0000\f\u00ba\u0001"+
		"\u0000\u0000\u0000\u000e\u00c0\u0001\u0000\u0000\u0000\u0010\u00c4\u0001"+
		"\u0000\u0000\u0000\u0012\u00c9\u0001\u0000\u0000\u0000\u0014\u00ce\u0001"+
		"\u0000\u0000\u0000\u0016\u00d5\u0001\u0000\u0000\u0000\u0018\u00db\u0001"+
		"\u0000\u0000\u0000\u001a\u00e7\u0001\u0000\u0000\u0000\u001c\u00e9\u0001"+
		"\u0000\u0000\u0000\u001e\u00ef\u0001\u0000\u0000\u0000 \u0106\u0001\u0000"+
		"\u0000\u0000\"\u0122\u0001\u0000\u0000\u0000$\u0130\u0001\u0000\u0000"+
		"\u0000&\u0134\u0001\u0000\u0000\u0000(\u0157\u0001\u0000\u0000\u0000*"+
		"\u01e9\u0001\u0000\u0000\u0000,\u02ae\u0001\u0000\u0000\u0000.\u02c9\u0001"+
		"\u0000\u0000\u00000\u02cb\u0001\u0000\u0000\u00002\u02da\u0001\u0000\u0000"+
		"\u00004\u02e9\u0001\u0000\u0000\u00006\u02eb\u0001\u0000\u0000\u00008"+
		"\u02f6\u0001\u0000\u0000\u0000:\u02f8\u0001\u0000\u0000\u0000<\u02fe\u0001"+
		"\u0000\u0000\u0000>\u0300\u0001\u0000\u0000\u0000@\u0302\u0001\u0000\u0000"+
		"\u0000B\u0304\u0001\u0000\u0000\u0000D\u0306\u0001\u0000\u0000\u0000F"+
		"\u0308\u0001\u0000\u0000\u0000H\u030a\u0001\u0000\u0000\u0000J\u030c\u0001"+
		"\u0000\u0000\u0000L\u030e\u0001\u0000\u0000\u0000N\u031e\u0001\u0000\u0000"+
		"\u0000P\u032c\u0001\u0000\u0000\u0000R\u0335\u0001\u0000\u0000\u0000T"+
		"\u033f\u0001\u0000\u0000\u0000V\u0346\u0001\u0000\u0000\u0000X\u0353\u0001"+
		"\u0000\u0000\u0000Z\u0364\u0001\u0000\u0000\u0000\\\u0373\u0001\u0000"+
		"\u0000\u0000^\u0375\u0001\u0000\u0000\u0000`\u037b\u0001\u0000\u0000\u0000"+
		"b\u037d\u0001\u0000\u0000\u0000d\u0380\u0001\u0000\u0000\u0000f\u0384"+
		"\u0001\u0000\u0000\u0000h\u038a\u0001\u0000\u0000\u0000j\u038f\u0001\u0000"+
		"\u0000\u0000l\u0396\u0001\u0000\u0000\u0000n\u0399\u0001\u0000\u0000\u0000"+
		"p\u039d\u0001\u0000\u0000\u0000r\u03a0\u0001\u0000\u0000\u0000t\u03a7"+
		"\u0001\u0000\u0000\u0000v\u03aa\u0001\u0000\u0000\u0000x\u03ac\u0001\u0000"+
		"\u0000\u0000z\u03b6\u0001\u0000\u0000\u0000|\u03b8\u0001\u0000\u0000\u0000"+
		"~\u03ba\u0001\u0000\u0000\u0000\u0080\u03bc\u0001\u0000\u0000\u0000\u0082"+
		"\u03be\u0001\u0000\u0000\u0000\u0084\u0086\u0003\u0002\u0001\u0000\u0085"+
		"\u0084\u0001\u0000\u0000\u0000\u0085\u0086\u0001\u0000\u0000\u0000\u0086"+
		"\u0087\u0001\u0000\u0000\u0000\u0087\u0088\u0005\u0000\u0000\u0001\u0088"+
		"\u0001\u0001\u0000\u0000\u0000\u0089\u008a\u0006\u0001\uffff\uffff\u0000"+
		"\u008a\u008b\u0003\u0006\u0003\u0000\u008b\u008c\u0003t:\u0000\u008c\u008f"+
		"\u0001\u0000\u0000\u0000\u008d\u008f\u0003t:\u0000\u008e\u0089\u0001\u0000"+
		"\u0000\u0000\u008e\u008d\u0001\u0000\u0000\u0000\u008f\u0096\u0001\u0000"+
		"\u0000\u0000\u0090\u0091\n\u0002\u0000\u0000\u0091\u0092\u0003\u0006\u0003"+
		"\u0000\u0092\u0093\u0003t:\u0000\u0093\u0095\u0001\u0000\u0000\u0000\u0094"+
		"\u0090\u0001\u0000\u0000\u0000\u0095\u0098\u0001\u0000\u0000\u0000\u0096"+
		"\u0094\u0001\u0000\u0000\u0000\u0096\u0097\u0001\u0000\u0000\u0000\u0097"+
		"\u0003\u0001\u0000\u0000\u0000\u0098\u0096\u0001\u0000\u0000\u0000\u0099"+
		"\u009a\u0003\u0006\u0003\u0000\u009a\u009b\u0003t:\u0000\u009b\u009d\u0001"+
		"\u0000\u0000\u0000\u009c\u0099\u0001\u0000\u0000\u0000\u009d\u00a0\u0001"+
		"\u0000\u0000\u0000\u009e\u009c\u0001\u0000\u0000\u0000\u009e\u009f\u0001"+
		"\u0000\u0000\u0000\u009f\u00a1\u0001\u0000\u0000\u0000\u00a0\u009e\u0001"+
		"\u0000\u0000\u0000\u00a1\u00a2\u0003\u0006\u0003\u0000\u00a2\u0005\u0001"+
		"\u0000\u0000\u0000\u00a3\u00aa\u0003\u000e\u0007\u0000\u00a4\u00aa\u0003"+
		"\u0010\b\u0000\u00a5\u00aa\u0003\u0012\t\u0000\u00a6\u00aa\u0003\n\u0005"+
		"\u0000\u00a7\u00aa\u0003\b\u0004\u0000\u00a8\u00aa\u0003(\u0014\u0000"+
		"\u00a9\u00a3\u0001\u0000\u0000\u0000\u00a9\u00a4\u0001\u0000\u0000\u0000"+
		"\u00a9\u00a5\u0001\u0000\u0000\u0000\u00a9\u00a6\u0001\u0000\u0000\u0000"+
		"\u00a9\u00a7\u0001\u0000\u0000\u0000\u00a9\u00a8\u0001\u0000\u0000\u0000"+
		"\u00aa\u0007\u0001\u0000\u0000\u0000\u00ab\u00ac\u00050\u0000\u0000\u00ac"+
		"\u00b1\u0003\f\u0006\u0000\u00ad\u00ae\u0005_\u0000\u0000\u00ae\u00b0"+
		"\u0003\f\u0006\u0000\u00af\u00ad\u0001\u0000\u0000\u0000\u00b0\u00b3\u0001"+
		"\u0000\u0000\u0000\u00b1\u00af\u0001\u0000\u0000\u0000\u00b1\u00b2\u0001"+
		"\u0000\u0000\u0000\u00b2\t\u0001\u0000\u0000\u0000\u00b3\u00b1\u0001\u0000"+
		"\u0000\u0000\u00b4\u00b5\u0005\u0011\u0000\u0000\u00b5\u00b6\u0003\f\u0006"+
		"\u0000\u00b6\u00b7\u0003\f\u0006\u0000\u00b7\u000b\u0001\u0000\u0000\u0000"+
		"\u00b8\u00bb\u0003 \u0010\u0000\u00b9\u00bb\u0003R)\u0000\u00ba\u00b8"+
		"\u0001\u0000\u0000\u0000\u00ba\u00b9\u0001\u0000\u0000\u0000\u00bb\r\u0001"+
		"\u0000\u0000\u0000\u00bc\u00bd\u0007\u0000\u0000\u0000\u00bd\u00be\u0003"+
		",\u0016\u0000\u00be\u00bf\u0003t:\u0000\u00bf\u00c1\u0001\u0000\u0000"+
		"\u0000\u00c0\u00bc\u0001\u0000\u0000\u0000\u00c1\u00c2\u0001\u0000\u0000"+
		"\u0000\u00c2\u00c0\u0001\u0000\u0000\u0000\u00c2\u00c3\u0001\u0000\u0000"+
		"\u0000\u00c3\u000f\u0001\u0000\u0000\u0000\u00c4\u00c5\u0005\u0013\u0000"+
		"\u0000\u00c5\u00c6\u0005O\u0000\u0000\u00c6\u00c7\u0003\u0002\u0001\u0000"+
		"\u00c7\u00c8\u0005N\u0000\u0000\u00c8\u0011\u0001\u0000\u0000\u0000\u00c9"+
		"\u00ca\u0005\u001c\u0000\u0000\u00ca\u00cb\u0005O\u0000\u0000\u00cb\u00cc"+
		"\u0003\u0002\u0001\u0000\u00cc\u00cd\u0005N\u0000\u0000\u00cd\u0013\u0001"+
		"\u0000\u0000\u0000\u00ce\u00cf\u0005#\u0000\u0000\u00cf\u00d1\u0003X,"+
		"\u0000\u00d0\u00d2\u0003\u0002\u0001\u0000\u00d1\u00d0\u0001\u0000\u0000"+
		"\u0000\u00d1\u00d2\u0001\u0000\u0000\u0000\u00d2\u00d3\u0001\u0000\u0000"+
		"\u0000\u00d3\u00d4\u0005\u001d\u0000\u0000\u00d4\u0015\u0001\u0000\u0000"+
		"\u0000\u00d5\u00d7\u0003\u001a\r\u0000\u00d6\u00d8\u0003\u0002\u0001\u0000"+
		"\u00d7\u00d6\u0001\u0000\u0000\u0000\u00d7\u00d8\u0001\u0000\u0000\u0000"+
		"\u00d8\u00d9\u0001\u0000\u0000\u0000\u00d9\u00da\u0005\u001d\u0000\u0000"+
		"\u00da\u0017\u0001\u0000\u0000\u0000\u00db\u00dc\u0005n\u0000\u0000\u00dc"+
		"\u00dd\u0003P(\u0000\u00dd\u00de\u0003t:\u0000\u00de\u0019\u0001\u0000"+
		"\u0000\u0000\u00df\u00e0\u0005\u0016\u0000\u0000\u00e0\u00e2\u0003X,\u0000"+
		"\u00e1\u00e3\u0003\u0018\f\u0000\u00e2\u00e1\u0001\u0000\u0000\u0000\u00e2"+
		"\u00e3\u0001\u0000\u0000\u0000\u00e3\u00e8\u0001\u0000\u0000\u0000\u00e4"+
		"\u00e5\u0005\u0016\u0000\u0000\u00e5\u00e6\u0005p\u0000\u0000\u00e6\u00e8"+
		"\u0003\\.\u0000\u00e7\u00df\u0001\u0000\u0000\u0000\u00e7\u00e4\u0001"+
		"\u0000\u0000\u0000\u00e8\u001b\u0001\u0000\u0000\u0000\u00e9\u00eb\u0003"+
		"\u001e\u000f\u0000\u00ea\u00ec\u0003\u0002\u0001\u0000\u00eb\u00ea\u0001"+
		"\u0000\u0000\u0000\u00eb\u00ec\u0001\u0000\u0000\u0000\u00ec\u00ed\u0001"+
		"\u0000\u0000\u0000\u00ed\u00ee\u0005\u001d\u0000\u0000\u00ee\u001d\u0001"+
		"\u0000\u0000\u0000\u00ef\u00f0\u0005\u0017\u0000\u0000\u00f0\u00f2\u0003"+
		" \u0010\u0000\u00f1\u00f3\u0003\"\u0011\u0000\u00f2\u00f1\u0001\u0000"+
		"\u0000\u0000\u00f2\u00f3\u0001\u0000\u0000\u0000\u00f3\u00f5\u0001\u0000"+
		"\u0000\u0000\u00f4\u00f6\u0003(\u0014\u0000\u00f5\u00f4\u0001\u0000\u0000"+
		"\u0000\u00f5\u00f6\u0001\u0000\u0000\u0000\u00f6\u00f7\u0001\u0000\u0000"+
		"\u0000\u00f7\u00f8\u0003t:\u0000\u00f8\u001f\u0001\u0000\u0000\u0000\u00f9"+
		"\u00fb\u0003X,\u0000\u00fa\u00fc\u0007\u0001\u0000\u0000\u00fb\u00fa\u0001"+
		"\u0000\u0000\u0000\u00fb\u00fc\u0001\u0000\u0000\u0000\u00fc\u0107\u0001"+
		"\u0000\u0000\u0000\u00fd\u0107\u0003Z-\u0000\u00fe\u0107\u0003H$\u0000"+
		"\u00ff\u0100\u0003F#\u0000\u0100\u0101\u0005M\u0000\u0000\u0101\u0107"+
		"\u0001\u0000\u0000\u0000\u0102\u0107\u0003D\"\u0000\u0103\u0107\u0003"+
		"B!\u0000\u0104\u0107\u0003@ \u0000\u0105\u0107\u0003>\u001f\u0000\u0106"+
		"\u00f9\u0001\u0000\u0000\u0000\u0106\u00fd\u0001\u0000\u0000\u0000\u0106"+
		"\u00fe\u0001\u0000\u0000\u0000\u0106\u00ff\u0001\u0000\u0000\u0000\u0106"+
		"\u0102\u0001\u0000\u0000\u0000\u0106\u0103\u0001\u0000\u0000\u0000\u0106"+
		"\u0104\u0001\u0000\u0000\u0000\u0106\u0105\u0001\u0000\u0000\u0000\u0107"+
		"!\u0001\u0000\u0000\u0000\u0108\u0114\u0005S\u0000\u0000\u0109\u0111\u0003"+
		"$\u0012\u0000\u010a\u010c\u0005_\u0000\u0000\u010b\u010d\u0003r9\u0000"+
		"\u010c\u010b\u0001\u0000\u0000\u0000\u010c\u010d\u0001\u0000\u0000\u0000"+
		"\u010d\u010e\u0001\u0000\u0000\u0000\u010e\u0110\u0003$\u0012\u0000\u010f"+
		"\u010a\u0001\u0000\u0000\u0000\u0110\u0113\u0001\u0000\u0000\u0000\u0111"+
		"\u010f\u0001\u0000\u0000\u0000\u0111\u0112\u0001\u0000\u0000\u0000\u0112"+
		"\u0115\u0001\u0000\u0000\u0000\u0113\u0111\u0001\u0000\u0000\u0000\u0114"+
		"\u0109\u0001\u0000\u0000\u0000\u0114\u0115\u0001\u0000\u0000\u0000\u0115"+
		"\u0116\u0001\u0000\u0000\u0000\u0116\u0123\u0005R\u0000\u0000\u0117\u011f"+
		"\u0003$\u0012\u0000\u0118\u011a\u0005_\u0000\u0000\u0119\u011b\u0003r"+
		"9\u0000\u011a\u0119\u0001\u0000\u0000\u0000\u011a\u011b\u0001\u0000\u0000"+
		"\u0000\u011b\u011c\u0001\u0000\u0000\u0000\u011c\u011e\u0003$\u0012\u0000"+
		"\u011d\u0118\u0001\u0000\u0000\u0000\u011e\u0121\u0001\u0000\u0000\u0000"+
		"\u011f\u011d\u0001\u0000\u0000\u0000\u011f\u0120\u0001\u0000\u0000\u0000"+
		"\u0120\u0123\u0001\u0000\u0000\u0000\u0121\u011f\u0001\u0000\u0000\u0000"+
		"\u0122\u0108\u0001\u0000\u0000\u0000\u0122\u0117\u0001\u0000\u0000\u0000"+
		"\u0123#\u0001\u0000\u0000\u0000\u0124\u0131\u0003\\.\u0000\u0125\u0126"+
		"\u0005J\u0000\u0000\u0126\u0131\u0003\\.\u0000\u0127\u0128\u0005I\u0000"+
		"\u0000\u0128\u0131\u0003\\.\u0000\u0129\u012a\u0005G\u0000\u0000\u012a"+
		"\u0131\u0003\\.\u0000\u012b\u0131\u0003T*\u0000\u012c\u012d\u0003\\.\u0000"+
		"\u012d\u012e\u0005h\u0000\u0000\u012e\u012f\u0003(\u0014\u0000\u012f\u0131"+
		"\u0001\u0000\u0000\u0000\u0130\u0124\u0001\u0000\u0000\u0000\u0130\u0125"+
		"\u0001\u0000\u0000\u0000\u0130\u0127\u0001\u0000\u0000\u0000\u0130\u0129"+
		"\u0001\u0000\u0000\u0000\u0130\u012b\u0001\u0000\u0000\u0000\u0130\u012c"+
		"\u0001\u0000\u0000\u0000\u0131%\u0001\u0000\u0000\u0000\u0132\u0135\u0003"+
		"(\u0014\u0000\u0133\u0135\u0003T*\u0000\u0134\u0132\u0001\u0000\u0000"+
		"\u0000\u0134\u0133\u0001\u0000\u0000\u0000\u0135\'\u0001\u0000\u0000\u0000"+
		"\u0136\u0137\u0006\u0014\uffff\uffff\u0000\u0137\u0158\u0003,\u0016\u0000"+
		"\u0138\u0139\u0003|>\u0000\u0139\u013a\u0003,\u0016\u0000\u013a\u0158"+
		"\u0001\u0000\u0000\u0000\u013b\u013c\u0003z=\u0000\u013c\u013d\u0003("+
		"\u0014\u0018\u013d\u0158\u0001\u0000\u0000\u0000\u013e\u013f\u0007\u0002"+
		"\u0000\u0000\u013f\u0158\u0003(\u0014\u0015\u0140\u0141\u0005\u0018\u0000"+
		"\u0000\u0141\u0158\u0003(\u0014\u0013\u0142\u0145\u0003J%\u0000\u0143"+
		"\u0145\u0005r\u0000\u0000\u0144\u0142\u0001\u0000\u0000\u0000\u0144\u0143"+
		"\u0001\u0000\u0000\u0000\u0145\u0146\u0001\u0000\u0000\u0000\u0146\u0158"+
		"\u0003(\u0014\r\u0147\u0148\u0003 \u0010\u0000\u0148\u014a\u00030\u0018"+
		"\u0000\u0149\u014b\u0003*\u0015\u0000\u014a\u0149\u0001\u0000\u0000\u0000"+
		"\u014a\u014b\u0001\u0000\u0000\u0000\u014b\u0158\u0001\u0000\u0000\u0000"+
		"\u014c\u014d\u0003X,\u0000\u014d\u014e\u0007\u0003\u0000\u0000\u014e\u0158"+
		"\u0001\u0000\u0000\u0000\u014f\u0150\u0007\u0004\u0000\u0000\u0150\u0152"+
		"\u0005\u0082\u0000\u0000\u0151\u0153\u0005\u0083\u0000\u0000\u0152\u0151"+
		"\u0001\u0000\u0000\u0000\u0152\u0153\u0001\u0000\u0000\u0000\u0153\u0155"+
		"\u0001\u0000\u0000\u0000\u0154\u0156\u0005\u0084\u0000\u0000\u0155\u0154"+
		"\u0001\u0000\u0000\u0000\u0155\u0156\u0001\u0000\u0000\u0000\u0156\u0158"+
		"\u0001\u0000\u0000\u0000\u0157\u0136\u0001\u0000\u0000\u0000\u0157\u0138"+
		"\u0001\u0000\u0000\u0000\u0157\u013b\u0001\u0000\u0000\u0000\u0157\u013e"+
		"\u0001\u0000\u0000\u0000\u0157\u0140\u0001\u0000\u0000\u0000\u0157\u0144"+
		"\u0001\u0000\u0000\u0000\u0157\u0147\u0001\u0000\u0000\u0000\u0157\u014c"+
		"\u0001\u0000\u0000\u0000\u0157\u014f\u0001\u0000\u0000\u0000\u0158\u01c5"+
		"\u0001\u0000\u0000\u0000\u0159\u015c\n\u001c\u0000\u0000\u015a\u015d\u0003"+
		"F#\u0000\u015b\u015d\u0003D\"\u0000\u015c\u015a\u0001\u0000\u0000\u0000"+
		"\u015c\u015b\u0001\u0000\u0000\u0000\u015d\u015f\u0001\u0000\u0000\u0000"+
		"\u015e\u0160\u0003r9\u0000\u015f\u015e\u0001\u0000\u0000\u0000\u015f\u0160"+
		"\u0001\u0000\u0000\u0000\u0160\u0161\u0001\u0000\u0000\u0000\u0161\u0162"+
		"\u0003(\u0014\u001d\u0162\u01c4\u0001\u0000\u0000\u0000\u0163\u0164\n"+
		"\u001b\u0000\u0000\u0164\u0166\u0005_\u0000\u0000\u0165\u0167\u0003r9"+
		"\u0000\u0166\u0165\u0001\u0000\u0000\u0000\u0166\u0167\u0001\u0000\u0000"+
		"\u0000\u0167\u0168\u0001\u0000\u0000\u0000\u0168\u01c4\u0003(\u0014\u001c"+
		"\u0169\u016a\n\u0017\u0000\u0000\u016a\u016c\u0003<\u001e\u0000\u016b"+
		"\u016d\u0003r9\u0000\u016c\u016b\u0001\u0000\u0000\u0000\u016c\u016d\u0001"+
		"\u0000\u0000\u0000\u016d\u016e\u0001\u0000\u0000\u0000\u016e\u016f\u0003"+
		"(\u0014\u0018\u016f\u01c4\u0001\u0000\u0000\u0000\u0170\u0172\n\u0011"+
		"\u0000\u0000\u0171\u0173\u0005_\u0000\u0000\u0172\u0171\u0001\u0000\u0000"+
		"\u0000\u0172\u0173\u0001\u0000\u0000\u0000\u0173\u0175\u0001\u0000\u0000"+
		"\u0000\u0174\u0176\u0005J\u0000\u0000\u0175\u0174\u0001\u0000\u0000\u0000"+
		"\u0175\u0176\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000"+
		"\u0177\u0179\u0005h\u0000\u0000\u0178\u017a\u0003r9\u0000\u0179\u0178"+
		"\u0001\u0000\u0000\u0000\u0179\u017a\u0001\u0000\u0000\u0000\u017a\u017b"+
		"\u0001\u0000\u0000\u0000\u017b\u01c4\u0003(\u0014\u0012\u017c\u017d\n"+
		"\u0010\u0000\u0000\u017d\u017e\u0005l\u0000\u0000\u017e\u01c4\u0003(\u0014"+
		"\u0011\u017f\u0180\n\u000f\u0000\u0000\u0180\u0181\u0005r\u0000\u0000"+
		"\u0181\u01c4\u0003(\u0014\u0010\u0182\u0183\n\u000e\u0000\u0000\u0183"+
		"\u0184\u0005[\u0000\u0000\u0184\u0185\u0005r\u0000\u0000\u0185\u01c4\u0003"+
		"(\u0014\u000f\u0186\u0187\n\f\u0000\u0000\u0187\u0189\u0003B!\u0000\u0188"+
		"\u018a\u0003r9\u0000\u0189\u0188\u0001\u0000\u0000\u0000\u0189\u018a\u0001"+
		"\u0000\u0000\u0000\u018a\u018b\u0001\u0000\u0000\u0000\u018b\u018c\u0003"+
		"(\u0014\r\u018c\u01c4\u0001\u0000\u0000\u0000\u018d\u018e\n\u000b\u0000"+
		"\u0000\u018e\u0190\u0003>\u001f\u0000\u018f\u0191\u0003r9\u0000\u0190"+
		"\u018f\u0001\u0000\u0000\u0000\u0190\u0191\u0001\u0000\u0000\u0000\u0191"+
		"\u0192\u0001\u0000\u0000\u0000\u0192\u0193\u0003(\u0014\f\u0193\u01c4"+
		"\u0001\u0000\u0000\u0000\u0194\u0195\n\n\u0000\u0000\u0195\u0197\u0003"+
		"@ \u0000\u0196\u0198\u0003r9\u0000\u0197\u0196\u0001\u0000\u0000\u0000"+
		"\u0197\u0198\u0001\u0000\u0000\u0000\u0198\u0199\u0001\u0000\u0000\u0000"+
		"\u0199\u019a\u0003(\u0014\u000b\u019a\u01c4\u0001\u0000\u0000\u0000\u019b"+
		"\u019c\n\t\u0000\u0000\u019c\u019e\u0003H$\u0000\u019d\u019f\u0003r9\u0000"+
		"\u019e\u019d\u0001\u0000\u0000\u0000\u019e\u019f\u0001\u0000\u0000\u0000"+
		"\u019f\u01a0\u0001\u0000\u0000\u0000\u01a0\u01a1\u0003(\u0014\n\u01a1"+
		"\u01c4\u0001\u0000\u0000\u0000\u01a2\u01a3\n\b\u0000\u0000\u01a3\u01a4"+
		"\u0005Y\u0000\u0000\u01a4\u01a5\u0003(\u0014\u0000\u01a5\u01a6\u0005\\"+
		"\u0000\u0000\u01a6\u01a7\u0003(\u0014\t\u01a7\u01c4\u0001\u0000\u0000"+
		"\u0000\u01a8\u01a9\n\u0016\u0000\u0000\u01a9\u01c4\u0005Y\u0000\u0000"+
		"\u01aa\u01ab\n\u0014\u0000\u0000\u01ab\u01ac\u0005Q\u0000\u0000\u01ac"+
		"\u01ad\u0003(\u0014\u0000\u01ad\u01ae\u0005P\u0000\u0000\u01ae\u01c4\u0001"+
		"\u0000\u0000\u0000\u01af\u01b0\n\u0012\u0000\u0000\u01b0\u01b2\u0007\u0005"+
		"\u0000\u0000\u01b1\u01b3\u0003(\u0014\u0000\u01b2\u01b1\u0001\u0000\u0000"+
		"\u0000\u01b2\u01b3\u0001\u0000\u0000\u0000\u01b3\u01c4\u0001\u0000\u0000"+
		"\u0000\u01b4\u01b5\n\u0007\u0000\u0000\u01b5\u01c4\u0003L&\u0000\u01b6"+
		"\u01b7\n\u0006\u0000\u0000\u01b7\u01c4\u0003*\u0015\u0000\u01b8\u01b9"+
		"\n\u0005\u0000\u0000\u01b9\u01ba\u0003<\u001e\u0000\u01ba\u01bb\u0005"+
		"\u0016\u0000\u0000\u01bb\u01c4\u0001\u0000\u0000\u0000\u01bc\u01bd\n\u0003"+
		"\u0000\u0000\u01bd\u01be\u0003<\u001e\u0000\u01be\u01bf\u0003 \u0010\u0000"+
		"\u01bf\u01c1\u00030\u0018\u0000\u01c0\u01c2\u0003*\u0015\u0000\u01c1\u01c0"+
		"\u0001\u0000\u0000\u0000\u01c1\u01c2\u0001\u0000\u0000\u0000\u01c2\u01c4"+
		"\u0001\u0000\u0000\u0000\u01c3\u0159\u0001\u0000\u0000\u0000\u01c3\u0163"+
		"\u0001\u0000\u0000\u0000\u01c3\u0169\u0001\u0000\u0000\u0000\u01c3\u0170"+
		"\u0001\u0000\u0000\u0000\u01c3\u017c\u0001\u0000\u0000\u0000\u01c3\u017f"+
		"\u0001\u0000\u0000\u0000\u01c3\u0182\u0001\u0000\u0000\u0000\u01c3\u0186"+
		"\u0001\u0000\u0000\u0000\u01c3\u018d\u0001\u0000\u0000\u0000\u01c3\u0194"+
		"\u0001\u0000\u0000\u0000\u01c3\u019b\u0001\u0000\u0000\u0000\u01c3\u01a2"+
		"\u0001\u0000\u0000\u0000\u01c3\u01a8\u0001\u0000\u0000\u0000\u01c3\u01aa"+
		"\u0001\u0000\u0000\u0000\u01c3\u01af\u0001\u0000\u0000\u0000\u01c3\u01b4"+
		"\u0001\u0000\u0000\u0000\u01c3\u01b6\u0001\u0000\u0000\u0000\u01c3\u01b8"+
		"\u0001\u0000\u0000\u0000\u01c3\u01bc\u0001\u0000\u0000\u0000\u01c4\u01c7"+
		"\u0001\u0000\u0000\u0000\u01c5\u01c3\u0001\u0000\u0000\u0000\u01c5\u01c6"+
		"\u0001\u0000\u0000\u0000\u01c6)\u0001\u0000\u0000\u0000\u01c7\u01c5\u0001"+
		"\u0000\u0000\u0000\u01c8\u01ca\u0005!\u0000\u0000\u01c9\u01cb\u0003r9"+
		"\u0000\u01ca\u01c9\u0001\u0000\u0000\u0000\u01ca\u01cb\u0001\u0000\u0000"+
		"\u0000\u01cb\u01cc\u0001\u0000\u0000\u0000\u01cc\u01ea\u0003(\u0014\u0000"+
		"\u01cd\u01cf\u00051\u0000\u0000\u01ce\u01d0\u0003r9\u0000\u01cf\u01ce"+
		"\u0001\u0000\u0000\u0000\u01cf\u01d0\u0001\u0000\u0000\u0000\u01d0\u01d1"+
		"\u0001\u0000\u0000\u0000\u01d1\u01ea\u0003(\u0014\u0000\u01d2\u01d4\u0005"+
		"4\u0000\u0000\u01d3\u01d5\u0003r9\u0000\u01d4\u01d3\u0001\u0000\u0000"+
		"\u0000\u01d4\u01d5\u0001\u0000\u0000\u0000\u01d5\u01d6\u0001\u0000\u0000"+
		"\u0000\u01d6\u01ea\u0003(\u0014\u0000\u01d7\u01d9\u00052\u0000\u0000\u01d8"+
		"\u01da\u0003r9\u0000\u01d9\u01d8\u0001\u0000\u0000\u0000\u01d9\u01da\u0001"+
		"\u0000\u0000\u0000\u01da\u01db\u0001\u0000\u0000\u0000\u01db\u01ea\u0003"+
		"(\u0014\u0000\u01dc\u01dd\u0005)\u0000\u0000\u01dd\u01ea\u0003\u0006\u0003"+
		"\u0000\u01de\u01e0\u0005\u0019\u0000\u0000\u01df\u01e1\u0003N\'\u0000"+
		"\u01e0\u01df\u0001\u0000\u0000\u0000\u01e0\u01e1\u0001\u0000\u0000\u0000"+
		"\u01e1\u01e3\u0001\u0000\u0000\u0000\u01e2\u01e4\u0003t:\u0000\u01e3\u01e2"+
		"\u0001\u0000\u0000\u0000\u01e3\u01e4\u0001\u0000\u0000\u0000\u01e4\u01e6"+
		"\u0001\u0000\u0000\u0000\u01e5\u01e7\u0003\u0002\u0001\u0000\u01e6\u01e5"+
		"\u0001\u0000\u0000\u0000\u01e6\u01e7\u0001\u0000\u0000\u0000\u01e7\u01e8"+
		"\u0001\u0000\u0000\u0000\u01e8\u01ea\u0005\u001d\u0000\u0000\u01e9\u01c8"+
		"\u0001\u0000\u0000\u0000\u01e9\u01cd\u0001\u0000\u0000\u0000\u01e9\u01d2"+
		"\u0001\u0000\u0000\u0000\u01e9\u01d7\u0001\u0000\u0000\u0000\u01e9\u01dc"+
		"\u0001\u0000\u0000\u0000\u01e9\u01de\u0001\u0000\u0000\u0000\u01ea+\u0001"+
		"\u0000\u0000\u0000\u01eb\u02af\u00058\u0000\u0000\u01ec\u02af\u0003\u0082"+
		"A\u0000\u01ed\u02af\u0003~?\u0000\u01ee\u02af\u0003R)\u0000\u01ef\u01f0"+
		"\u0005S\u0000\u0000\u01f0\u01f1\u0003(\u0014\u0000\u01f1\u01f2\u0005R"+
		"\u0000\u0000\u01f2\u02af\u0001\u0000\u0000\u0000\u01f3\u02af\u0003L&\u0000"+
		"\u01f4\u01f6\u0005\u0014\u0000\u0000\u01f5\u01f7\u0003(\u0014\u0000\u01f6"+
		"\u01f5\u0001\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7"+
		"\u02af\u0001\u0000\u0000\u0000\u01f8\u01fa\u0005+\u0000\u0000\u01f9\u01fb"+
		"\u0003(\u0014\u0000\u01fa\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001"+
		"\u0000\u0000\u0000\u01fb\u02af\u0001\u0000\u0000\u0000\u01fc\u01fd\u0005"+
		"\'\u0000\u0000\u01fd\u02af\u0003(\u0014\u0000\u01fe\u0200\u00055\u0000"+
		"\u0000\u01ff\u0201\u0003(\u0014\u0000\u0200\u01ff\u0001\u0000\u0000\u0000"+
		"\u0200\u0201\u0001\u0000\u0000\u0000\u0201\u02af\u0001\u0000\u0000\u0000"+
		"\u0202\u0203\u0005\u0012\u0000\u0000\u0203\u0205\u0003t:\u0000\u0204\u0206"+
		"\u0003\u0002\u0001\u0000\u0205\u0204\u0001\u0000\u0000\u0000\u0205\u0206"+
		"\u0001\u0000\u0000\u0000\u0206\u0208\u0001\u0000\u0000\u0000\u0207\u0209"+
		"\u0003x<\u0000\u0208\u0207\u0001\u0000\u0000\u0000\u0208\u0209\u0001\u0000"+
		"\u0000\u0000\u0209\u020b\u0001\u0000\u0000\u0000\u020a\u020c\u0003p8\u0000"+
		"\u020b\u020a\u0001\u0000\u0000\u0000\u020b\u020c\u0001\u0000\u0000\u0000"+
		"\u020c\u020e\u0001\u0000\u0000\u0000\u020d\u020f\u0003\u0002\u0001\u0000"+
		"\u020e\u020d\u0001\u0000\u0000\u0000\u020e\u020f\u0001\u0000\u0000\u0000"+
		"\u020f\u0210\u0001\u0000\u0000\u0000\u0210\u0211\u0005\u001d\u0000\u0000"+
		"\u0211\u02af\u0001\u0000\u0000\u0000\u0212\u0214\u0005!\u0000\u0000\u0213"+
		"\u0215\u0003r9\u0000\u0214\u0213\u0001\u0000\u0000\u0000\u0214\u0215\u0001"+
		"\u0000\u0000\u0000\u0215\u0216\u0001\u0000\u0000\u0000\u0216\u0217\u0003"+
		"(\u0014\u0000\u0217\u0219\u0003l6\u0000\u0218\u021a\u0003\u0002\u0001"+
		"\u0000\u0219\u0218\u0001\u0000\u0000\u0000\u0219\u021a\u0001\u0000\u0000"+
		"\u0000\u021a\u021e\u0001\u0000\u0000\u0000\u021b\u021d\u00038\u001c\u0000"+
		"\u021c\u021b\u0001\u0000\u0000\u0000\u021d\u0220\u0001\u0000\u0000\u0000"+
		"\u021e\u021c\u0001\u0000\u0000\u0000\u021e\u021f\u0001\u0000\u0000\u0000"+
		"\u021f\u0221\u0001\u0000\u0000\u0000\u0220\u021e\u0001\u0000\u0000\u0000"+
		"\u0221\u0222\u0005\u001d\u0000\u0000\u0222\u02af\u0001\u0000\u0000\u0000"+
		"\u0223\u0224\u00053\u0000\u0000\u0224\u0225\u0003(\u0014\u0000\u0225\u0226"+
		"\u0003l6\u0000\u0226\u0227\u0003\u0004\u0002\u0000\u0227\u0228\u0005\u001d"+
		"\u0000\u0000\u0228\u02af\u0001\u0000\u0000\u0000\u0229\u022b\u00051\u0000"+
		"\u0000\u022a\u022c\u0003r9\u0000\u022b\u022a\u0001\u0000\u0000\u0000\u022b"+
		"\u022c\u0001\u0000\u0000\u0000\u022c\u022d\u0001\u0000\u0000\u0000\u022d"+
		"\u022e\u0003(\u0014\u0000\u022e\u0230\u0003l6\u0000\u022f\u0231\u0003"+
		"\u0002\u0001\u0000\u0230\u022f\u0001\u0000\u0000\u0000\u0230\u0231\u0001"+
		"\u0000\u0000\u0000\u0231\u0233\u0001\u0000\u0000\u0000\u0232\u0234\u0003"+
		":\u001d\u0000\u0233\u0232\u0001\u0000\u0000\u0000\u0233\u0234\u0001\u0000"+
		"\u0000\u0000\u0234\u0235\u0001\u0000\u0000\u0000\u0235\u0236\u0005\u001d"+
		"\u0000\u0000\u0236\u02af\u0001\u0000\u0000\u0000\u0237\u0239\u0005\u0015"+
		"\u0000\u0000\u0238\u023a\u0005L\u0000\u0000\u0239\u0238\u0001\u0000\u0000"+
		"\u0000\u0239\u023a\u0001\u0000\u0000\u0000\u023a\u023c\u0001\u0000\u0000"+
		"\u0000\u023b\u023d\u0003\u0002\u0001\u0000\u023c\u023b\u0001\u0000\u0000"+
		"\u0000\u023c\u023d\u0001\u0000\u0000\u0000\u023d\u023f\u0001\u0000\u0000"+
		"\u0000\u023e\u0240\u00034\u001a\u0000\u023f\u023e\u0001\u0000\u0000\u0000"+
		"\u0240\u0241\u0001\u0000\u0000\u0000\u0241\u023f\u0001\u0000\u0000\u0000"+
		"\u0241\u0242\u0001\u0000\u0000\u0000\u0242\u0243\u0001\u0000\u0000\u0000"+
		"\u0243\u0244\u0005\u001d\u0000\u0000\u0244\u02af\u0001\u0000\u0000\u0000"+
		"\u0245\u0247\u00054\u0000\u0000\u0246\u0248\u0003r9\u0000\u0247\u0246"+
		"\u0001\u0000\u0000\u0000\u0247\u0248\u0001\u0000\u0000\u0000\u0248\u0249"+
		"\u0001\u0000\u0000\u0000\u0249\u024a\u0003(\u0014\u0000\u024a\u024c\u0003"+
		"j5\u0000\u024b\u024d\u0003\u0002\u0001\u0000\u024c\u024b\u0001\u0000\u0000"+
		"\u0000\u024c\u024d\u0001\u0000\u0000\u0000\u024d\u024e\u0001\u0000\u0000"+
		"\u0000\u024e\u024f\u0005\u001d\u0000\u0000\u024f\u02af\u0001\u0000\u0000"+
		"\u0000\u0250\u0252\u00052\u0000\u0000\u0251\u0253\u0003r9\u0000\u0252"+
		"\u0251\u0001\u0000\u0000\u0000\u0252\u0253\u0001\u0000\u0000\u0000\u0253"+
		"\u0254\u0001\u0000\u0000\u0000\u0254\u0255\u0003(\u0014\u0000\u0255\u0257"+
		"\u0003j5\u0000\u0256\u0258\u0003\u0002\u0001\u0000\u0257\u0256\u0001\u0000"+
		"\u0000\u0000\u0257\u0258\u0001\u0000\u0000\u0000\u0258\u0259\u0001\u0000"+
		"\u0000\u0000\u0259\u025a\u0005\u001d\u0000\u0000\u025a\u02af\u0001\u0000"+
		"\u0000\u0000\u025b\u025d\u0005 \u0000\u0000\u025c\u025e\u0003r9\u0000"+
		"\u025d\u025c\u0001\u0000\u0000\u0000\u025d\u025e\u0001\u0000\u0000\u0000"+
		"\u025e\u025f\u0001\u0000\u0000\u0000\u025f\u0260\u0003(\u0014\u0000\u0260"+
		"\u0261\u0005\"\u0000\u0000\u0261\u0264\u00036\u001b\u0000\u0262\u0265"+
		"\u0005\u0019\u0000\u0000\u0263\u0265\u0003r9\u0000\u0264\u0262\u0001\u0000"+
		"\u0000\u0000\u0264\u0263\u0001\u0000\u0000\u0000\u0265\u0267\u0001\u0000"+
		"\u0000\u0000\u0266\u0268\u0003\u0002\u0001\u0000\u0267\u0266\u0001\u0000"+
		"\u0000\u0000\u0267\u0268\u0001\u0000\u0000\u0000\u0268\u0269\u0001\u0000"+
		"\u0000\u0000\u0269\u026a\u0005\u001d\u0000\u0000\u026a\u02af\u0001\u0000"+
		"\u0000\u0000\u026b\u02af\u0003\u0016\u000b\u0000\u026c\u02af\u0003\u001c"+
		"\u000e\u0000\u026d\u02af\u0003\u0014\n\u0000\u026e\u026f\u0003 \u0010"+
		"\u0000\u026f\u0270\u0003.\u0017\u0000\u0270\u02af\u0001\u0000\u0000\u0000"+
		"\u0271\u0273\u0005O\u0000\u0000\u0272\u0274\u0003r9\u0000\u0273\u0272"+
		"\u0001\u0000\u0000\u0000\u0273\u0274\u0001\u0000\u0000\u0000\u0274\u0275"+
		"\u0001\u0000\u0000\u0000\u0275\u0277\u0003T*\u0000\u0276\u0278\u0003r"+
		"9\u0000\u0277\u0276\u0001\u0000\u0000\u0000\u0277\u0278\u0001\u0000\u0000"+
		"\u0000\u0278\u0280\u0001\u0000\u0000\u0000\u0279\u027b\u0005_\u0000\u0000"+
		"\u027a\u027c\u0003r9\u0000\u027b\u027a\u0001\u0000\u0000\u0000\u027b\u027c"+
		"\u0001\u0000\u0000\u0000\u027c\u027d\u0001\u0000\u0000\u0000\u027d\u027f"+
		"\u0003T*\u0000\u027e\u0279\u0001\u0000\u0000\u0000\u027f\u0282\u0001\u0000"+
		"\u0000\u0000\u0280\u027e\u0001\u0000\u0000\u0000\u0280\u0281\u0001\u0000"+
		"\u0000\u0000\u0281\u0284\u0001\u0000\u0000\u0000\u0282\u0280\u0001\u0000"+
		"\u0000\u0000\u0283\u0285\u0005_\u0000\u0000\u0284\u0283\u0001\u0000\u0000"+
		"\u0000\u0284\u0285\u0001\u0000\u0000\u0000\u0285\u0287\u0001\u0000\u0000"+
		"\u0000\u0286\u0288\u0003r9\u0000\u0287\u0286\u0001\u0000\u0000\u0000\u0287"+
		"\u0288\u0001\u0000\u0000\u0000\u0288\u0289\u0001\u0000\u0000\u0000\u0289"+
		"\u028a\u0005N\u0000\u0000\u028a\u02af\u0001\u0000\u0000\u0000\u028b\u028d"+
		"\u0005Q\u0000\u0000\u028c\u028e\u0003r9\u0000\u028d\u028c\u0001\u0000"+
		"\u0000\u0000\u028d\u028e\u0001\u0000\u0000\u0000\u028e\u028f\u0001\u0000"+
		"\u0000\u0000\u028f\u0291\u0003(\u0014\u0000\u0290\u0292\u0003r9\u0000"+
		"\u0291\u0290\u0001\u0000\u0000\u0000\u0291\u0292\u0001\u0000\u0000\u0000"+
		"\u0292\u029a\u0001\u0000\u0000\u0000\u0293\u0295\u0005_\u0000\u0000\u0294"+
		"\u0296\u0003r9\u0000\u0295\u0294\u0001\u0000\u0000\u0000\u0295\u0296\u0001"+
		"\u0000\u0000\u0000\u0296\u0297\u0001\u0000\u0000\u0000\u0297\u0299\u0003"+
		"(\u0014\u0000\u0298\u0293\u0001\u0000\u0000\u0000\u0299\u029c\u0001\u0000"+
		"\u0000\u0000\u029a\u0298\u0001\u0000\u0000\u0000\u029a\u029b\u0001\u0000"+
		"\u0000\u0000\u029b\u029e\u0001\u0000\u0000\u0000\u029c\u029a\u0001\u0000"+
		"\u0000\u0000\u029d\u029f\u0005_\u0000\u0000\u029e\u029d\u0001\u0000\u0000"+
		"\u0000\u029e\u029f\u0001\u0000\u0000\u0000\u029f\u02a1\u0001\u0000\u0000"+
		"\u0000\u02a0\u02a2\u0003r9\u0000\u02a1\u02a0\u0001\u0000\u0000\u0000\u02a1"+
		"\u02a2\u0001\u0000\u0000\u0000\u02a2\u02a3\u0001\u0000\u0000\u0000\u02a3"+
		"\u02a4\u0005P\u0000\u0000\u02a4\u02af\u0001\u0000\u0000\u0000\u02a5\u02a6"+
		"\u0005S\u0000\u0000\u02a6\u02a7\u0003(\u0014\u0000\u02a7\u02a9\u0007\u0005"+
		"\u0000\u0000\u02a8\u02aa\u0003(\u0014\u0000\u02a9\u02a8\u0001\u0000\u0000"+
		"\u0000\u02a9\u02aa\u0001\u0000\u0000\u0000\u02aa\u02ab\u0001\u0000\u0000"+
		"\u0000\u02ab\u02ac\u0005R\u0000\u0000\u02ac\u02af\u0001\u0000\u0000\u0000"+
		"\u02ad\u02af\u0003V+\u0000\u02ae\u01eb\u0001\u0000\u0000\u0000\u02ae\u01ec"+
		"\u0001\u0000\u0000\u0000\u02ae\u01ed\u0001\u0000\u0000\u0000\u02ae\u01ee"+
		"\u0001\u0000\u0000\u0000\u02ae\u01ef\u0001\u0000\u0000\u0000\u02ae\u01f3"+
		"\u0001\u0000\u0000\u0000\u02ae\u01f4\u0001\u0000\u0000\u0000\u02ae\u01f8"+
		"\u0001\u0000\u0000\u0000\u02ae\u01fc\u0001\u0000\u0000\u0000\u02ae\u01fe"+
		"\u0001\u0000\u0000\u0000\u02ae\u0202\u0001\u0000\u0000\u0000\u02ae\u0212"+
		"\u0001\u0000\u0000\u0000\u02ae\u0223\u0001\u0000\u0000\u0000\u02ae\u0229"+
		"\u0001\u0000\u0000\u0000\u02ae\u0237\u0001\u0000\u0000\u0000\u02ae\u0245"+
		"\u0001\u0000\u0000\u0000\u02ae\u0250\u0001\u0000\u0000\u0000\u02ae\u025b"+
		"\u0001\u0000\u0000\u0000\u02ae\u026b\u0001\u0000\u0000\u0000\u02ae\u026c"+
		"\u0001\u0000\u0000\u0000\u02ae\u026d\u0001\u0000\u0000\u0000\u02ae\u026e"+
		"\u0001\u0000\u0000\u0000\u02ae\u0271\u0001\u0000\u0000\u0000\u02ae\u028b"+
		"\u0001\u0000\u0000\u0000\u02ae\u02a5\u0001\u0000\u0000\u0000\u02ae\u02ad"+
		"\u0001\u0000\u0000\u0000\u02af-\u0001\u0000\u0000\u0000\u02b0\u02b2\u0005"+
		"S\u0000\u0000\u02b1\u02b3\u0003r9\u0000\u02b2\u02b1\u0001\u0000\u0000"+
		"\u0000\u02b2\u02b3\u0001\u0000\u0000\u0000\u02b3\u02b4\u0001\u0000\u0000"+
		"\u0000\u02b4\u02bc\u0003&\u0013\u0000\u02b5\u02b7\u0005_\u0000\u0000\u02b6"+
		"\u02b8\u0003r9\u0000\u02b7\u02b6\u0001\u0000\u0000\u0000\u02b7\u02b8\u0001"+
		"\u0000\u0000\u0000\u02b8\u02b9\u0001\u0000\u0000\u0000\u02b9\u02bb\u0003"+
		"&\u0013\u0000\u02ba\u02b5\u0001\u0000\u0000\u0000\u02bb\u02be\u0001\u0000"+
		"\u0000\u0000\u02bc\u02ba\u0001\u0000\u0000\u0000\u02bc\u02bd\u0001\u0000"+
		"\u0000\u0000\u02bd\u02c0\u0001\u0000\u0000\u0000\u02be\u02bc\u0001\u0000"+
		"\u0000\u0000\u02bf\u02c1\u0003r9\u0000\u02c0\u02bf\u0001\u0000\u0000\u0000"+
		"\u02c0\u02c1\u0001\u0000\u0000\u0000\u02c1\u02c2\u0001\u0000\u0000\u0000"+
		"\u02c2\u02c3\u0005R\u0000\u0000\u02c3\u02ca\u0001\u0000\u0000\u0000\u02c4"+
		"\u02c6\u0005S\u0000\u0000\u02c5\u02c7\u0003r9\u0000\u02c6\u02c5\u0001"+
		"\u0000\u0000\u0000\u02c6\u02c7\u0001\u0000\u0000\u0000\u02c7\u02c8\u0001"+
		"\u0000\u0000\u0000\u02c8\u02ca\u0005R\u0000\u0000\u02c9\u02b0\u0001\u0000"+
		"\u0000\u0000\u02c9\u02c4\u0001\u0000\u0000\u0000\u02ca/\u0001\u0000\u0000"+
		"\u0000\u02cb\u02d3\u0003&\u0013\u0000\u02cc\u02ce\u0005_\u0000\u0000\u02cd"+
		"\u02cf\u0003r9\u0000\u02ce\u02cd\u0001\u0000\u0000\u0000\u02ce\u02cf\u0001"+
		"\u0000\u0000\u0000\u02cf\u02d0\u0001\u0000\u0000\u0000\u02d0\u02d2\u0003"+
		"&\u0013\u0000\u02d1\u02cc\u0001\u0000\u0000\u0000\u02d2\u02d5\u0001\u0000"+
		"\u0000\u0000\u02d3\u02d1\u0001\u0000\u0000\u0000\u02d3\u02d4\u0001\u0000"+
		"\u0000\u0000\u02d41\u0001\u0000\u0000\u0000\u02d5\u02d3\u0001\u0000\u0000"+
		"\u0000\u02d6\u02db\u0003P(\u0000\u02d7\u02db\u0003T*\u0000\u02d8\u02d9"+
		"\u0005i\u0000\u0000\u02d9\u02db\u0003\\.\u0000\u02da\u02d6\u0001\u0000"+
		"\u0000\u0000\u02da\u02d7\u0001\u0000\u0000\u0000\u02da\u02d8\u0001\u0000"+
		"\u0000\u0000\u02db3\u0001\u0000\u0000\u0000\u02dc\u02dd\u00053\u0000\u0000"+
		"\u02dd\u02e2\u00036\u001b\u0000\u02de\u02df\u0005_\u0000\u0000\u02df\u02e1"+
		"\u00036\u001b\u0000\u02e0\u02de\u0001\u0000\u0000\u0000\u02e1\u02e4\u0001"+
		"\u0000\u0000\u0000\u02e2\u02e0\u0001\u0000\u0000\u0000\u02e2\u02e3\u0001"+
		"\u0000\u0000\u0000\u02e3\u02e5\u0001\u0000\u0000\u0000\u02e4\u02e2\u0001"+
		"\u0000\u0000\u0000\u02e5\u02e6\u0003l6\u0000\u02e6\u02e7\u0003\u0002\u0001"+
		"\u0000\u02e7\u02ea\u0001\u0000\u0000\u0000\u02e8\u02ea\u0003:\u001d\u0000"+
		"\u02e9\u02dc\u0001\u0000\u0000\u0000\u02e9\u02e8\u0001\u0000\u0000\u0000"+
		"\u02ea5\u0001\u0000\u0000\u0000\u02eb\u02ec\u0003(\u0014\u0000\u02ec7"+
		"\u0001\u0000\u0000\u0000\u02ed\u02ef\u0005\u001b\u0000\u0000\u02ee\u02f0"+
		"\u0003r9\u0000\u02ef\u02ee\u0001\u0000\u0000\u0000\u02ef\u02f0\u0001\u0000"+
		"\u0000\u0000\u02f0\u02f1\u0001\u0000\u0000\u0000\u02f1\u02f2\u0003(\u0014"+
		"\u0000\u02f2\u02f3\u0003l6\u0000\u02f3\u02f4\u0003\u0002\u0001\u0000\u02f4"+
		"\u02f7\u0001\u0000\u0000\u0000\u02f5\u02f7\u0003:\u001d\u0000\u02f6\u02ed"+
		"\u0001\u0000\u0000\u0000\u02f6\u02f5\u0001\u0000\u0000\u0000\u02f79\u0001"+
		"\u0000\u0000\u0000\u02f8\u02fa\u0005\u001a\u0000\u0000\u02f9\u02fb\u0003"+
		"r9\u0000\u02fa\u02f9\u0001\u0000\u0000\u0000\u02fa\u02fb\u0001\u0000\u0000"+
		"\u0000\u02fb\u02fc\u0001\u0000\u0000\u0000\u02fc\u02fd\u0003\u0002\u0001"+
		"\u0000\u02fd;\u0001\u0000\u0000\u0000\u02fe\u02ff\u0007\u0006\u0000\u0000"+
		"\u02ff=\u0001\u0000\u0000\u0000\u0300\u0301\u0007\u0007\u0000\u0000\u0301"+
		"?\u0001\u0000\u0000\u0000\u0302\u0303\u0007\b\u0000\u0000\u0303A\u0001"+
		"\u0000\u0000\u0000\u0304\u0305\u0007\t\u0000\u0000\u0305C\u0001\u0000"+
		"\u0000\u0000\u0306\u0307\u0007\n\u0000\u0000\u0307E\u0001\u0000\u0000"+
		"\u0000\u0308\u0309\u0007\u000b\u0000\u0000\u0309G\u0001\u0000\u0000\u0000"+
		"\u030a\u030b\u0007\f\u0000\u0000\u030bI\u0001\u0000\u0000\u0000\u030c"+
		"\u030d\u0007\r\u0000\u0000\u030dK\u0001\u0000\u0000\u0000\u030e\u0310"+
		"\u0005O\u0000\u0000\u030f\u0311\u0003r9\u0000\u0310\u030f\u0001\u0000"+
		"\u0000\u0000\u0310\u0311\u0001\u0000\u0000\u0000\u0311\u0313\u0001\u0000"+
		"\u0000\u0000\u0312\u0314\u0003N\'\u0000\u0313\u0312\u0001\u0000\u0000"+
		"\u0000\u0313\u0314\u0001\u0000\u0000\u0000\u0314\u0316\u0001\u0000\u0000"+
		"\u0000\u0315\u0317\u0003r9\u0000\u0316\u0315\u0001\u0000\u0000\u0000\u0316"+
		"\u0317\u0001\u0000\u0000\u0000\u0317\u0318\u0001\u0000\u0000\u0000\u0318"+
		"\u031a\u0003\u0002\u0001\u0000\u0319\u031b\u0003r9\u0000\u031a\u0319\u0001"+
		"\u0000\u0000\u0000\u031a\u031b\u0001\u0000\u0000\u0000\u031b\u031c\u0001"+
		"\u0000\u0000\u0000\u031c\u031d\u0005N\u0000\u0000\u031dM\u0001\u0000\u0000"+
		"\u0000\u031e\u031f\u0005c\u0000\u0000\u031f\u0324\u0003(\u0014\u0000\u0320"+
		"\u0321\u0005_\u0000\u0000\u0321\u0323\u0003(\u0014\u0000\u0322\u0320\u0001"+
		"\u0000\u0000\u0000\u0323\u0326\u0001\u0000\u0000\u0000\u0324\u0322\u0001"+
		"\u0000\u0000\u0000\u0324\u0325\u0001\u0000\u0000\u0000\u0325\u0327\u0001"+
		"\u0000\u0000\u0000\u0326\u0324\u0001\u0000\u0000\u0000\u0327\u0328\u0005"+
		"c\u0000\u0000\u0328O\u0001\u0000\u0000\u0000\u0329\u032d\u0003X,\u0000"+
		"\u032a\u032b\u0005\\\u0000\u0000\u032b\u032d\u0003X,\u0000\u032c\u0329"+
		"\u0001\u0000\u0000\u0000\u032c\u032a\u0001\u0000\u0000\u0000\u032dQ\u0001"+
		"\u0000\u0000\u0000\u032e\u032f\u0005\\\u0000\u0000\u032f\u0330\u0003\\"+
		".\u0000\u0330\u0331\u0005\\\u0000\u0000\u0331\u0332\u0003n7\u0000\u0332"+
		"\u0336\u0001\u0000\u0000\u0000\u0333\u0334\u0005\\\u0000\u0000\u0334\u0336"+
		"\u0003 \u0010\u0000\u0335\u032e\u0001\u0000\u0000\u0000\u0335\u0333\u0001"+
		"\u0000\u0000\u0000\u0336S\u0001\u0000\u0000\u0000\u0337\u0338\u0003(\u0014"+
		"\u0000\u0338\u0339\u0005i\u0000\u0000\u0339\u033a\u0003(\u0014\u0000\u033a"+
		"\u0340\u0001\u0000\u0000\u0000\u033b\u033c\u0003(\u0014\u0000\u033c\u033d"+
		"\u0005\\\u0000\u0000\u033d\u033e\u0003(\u0014\u0000\u033e\u0340\u0001"+
		"\u0000\u0000\u0000\u033f\u0337\u0001\u0000\u0000\u0000\u033f\u033b\u0001"+
		"\u0000\u0000\u0000\u0340U\u0001\u0000\u0000\u0000\u0341\u0342\u0006+\uffff"+
		"\uffff\u0000\u0342\u0347\u0003\\.\u0000\u0343\u0347\u0003Z-\u0000\u0344"+
		"\u0345\u0005]\u0000\u0000\u0345\u0347\u0003V+\u0001\u0346\u0341\u0001"+
		"\u0000\u0000\u0000\u0346\u0343\u0001\u0000\u0000\u0000\u0346\u0344\u0001"+
		"\u0000\u0000\u0000\u0347\u0350\u0001\u0000\u0000\u0000\u0348\u0349\n\u0002"+
		"\u0000\u0000\u0349\u034c\u0005]\u0000\u0000\u034a\u034d\u0003\\.\u0000"+
		"\u034b\u034d\u0003Z-\u0000\u034c\u034a\u0001\u0000\u0000\u0000\u034c\u034b"+
		"\u0001\u0000\u0000\u0000\u034d\u034f\u0001\u0000\u0000\u0000\u034e\u0348"+
		"\u0001\u0000\u0000\u0000\u034f\u0352\u0001\u0000\u0000\u0000\u0350\u034e"+
		"\u0001\u0000\u0000\u0000\u0350\u0351\u0001\u0000\u0000\u0000\u0351W\u0001"+
		"\u0000\u0000\u0000\u0352\u0350\u0001\u0000\u0000\u0000\u0353\u0358\u0003"+
		"\\.\u0000\u0354\u0355\u0007\u000e\u0000\u0000\u0355\u0357\u0003\\.\u0000"+
		"\u0356\u0354\u0001\u0000\u0000\u0000\u0357\u035a\u0001\u0000\u0000\u0000"+
		"\u0358\u0356\u0001\u0000\u0000\u0000\u0358\u0359\u0001\u0000\u0000\u0000"+
		"\u0359Y\u0001\u0000\u0000\u0000\u035a\u0358\u0001\u0000\u0000\u0000\u035b"+
		"\u0365\u00057\u0000\u0000\u035c\u0365\u0003\u0080@\u0000\u035d\u0365\u0003"+
		"n7\u0000\u035e\u0365\u00056\u0000\u0000\u035f\u0365\u0007\u000f\u0000"+
		"\u0000\u0360\u0365\u0005%\u0000\u0000\u0361\u0362\u00057\u0000\u0000\u0362"+
		"\u0365\u0005V\u0000\u0000\u0363\u0365\u0005y\u0000\u0000\u0364\u035b\u0001"+
		"\u0000\u0000\u0000\u0364\u035c\u0001\u0000\u0000\u0000\u0364\u035d\u0001"+
		"\u0000\u0000\u0000\u0364\u035e\u0001\u0000\u0000\u0000\u0364\u035f\u0001"+
		"\u0000\u0000\u0000\u0364\u0360\u0001\u0000\u0000\u0000\u0364\u0361\u0001"+
		"\u0000\u0000\u0000\u0364\u0363\u0001\u0000\u0000\u0000\u0365[\u0001\u0000"+
		"\u0000\u0000\u0366\u0374\u0005x\u0000\u0000\u0367\u0374\u0003b1\u0000"+
		"\u0368\u0374\u0003d2\u0000\u0369\u0374\u0003f3\u0000\u036a\u0374\u0003"+
		"h4\u0000\u036b\u0374\u0003^/\u0000\u036c\u0374\u0005(\u0000\u0000\u036d"+
		"\u0374\u0005*\u0000\u0000\u036e\u0374\u0005\u0014\u0000\u0000\u036f\u0374"+
		"\u0005,\u0000\u0000\u0370\u0374\u0005-\u0000\u0000\u0371\u0374\u0005%"+
		"\u0000\u0000\u0372\u0374\u0003`0\u0000\u0373\u0366\u0001\u0000\u0000\u0000"+
		"\u0373\u0367\u0001\u0000\u0000\u0000\u0373\u0368\u0001\u0000\u0000\u0000"+
		"\u0373\u0369\u0001\u0000\u0000\u0000\u0373\u036a\u0001\u0000\u0000\u0000"+
		"\u0373\u036b\u0001\u0000\u0000\u0000\u0373\u036c\u0001\u0000\u0000\u0000"+
		"\u0373\u036d\u0001\u0000\u0000\u0000\u0373\u036e\u0001\u0000\u0000\u0000"+
		"\u0373\u036f\u0001\u0000\u0000\u0000\u0373\u0370\u0001\u0000\u0000\u0000"+
		"\u0373\u0371\u0001\u0000\u0000\u0000\u0373\u0372\u0001\u0000\u0000\u0000"+
		"\u0374]\u0001\u0000\u0000\u0000\u0375\u0376\u0005$\u0000\u0000\u0376_"+
		"\u0001\u0000\u0000\u0000\u0377\u0378\u0005O\u0000\u0000\u0378\u037c\u0005"+
		"N\u0000\u0000\u0379\u037a\u0005Q\u0000\u0000\u037a\u037c\u0005P\u0000"+
		"\u0000\u037b\u0377\u0001\u0000\u0000\u0000\u037b\u0379\u0001\u0000\u0000"+
		"\u0000\u037ca\u0001\u0000\u0000\u0000\u037d\u037e\u0005L\u0000\u0000\u037e"+
		"\u037f\u0005x\u0000\u0000\u037fc\u0001\u0000\u0000\u0000\u0380\u0381\u0005"+
		"M\u0000\u0000\u0381\u0382\u0005M\u0000\u0000\u0382\u0383\u0005x\u0000"+
		"\u0000\u0383e\u0001\u0000\u0000\u0000\u0384\u0385\u0005M\u0000\u0000\u0385"+
		"\u0386\u0005x\u0000\u0000\u0386g\u0001\u0000\u0000\u0000\u0387\u0388\u0005"+
		"L\u0000\u0000\u0388\u038b\u00056\u0000\u0000\u0389\u038b\u0005:\u0000"+
		"\u0000\u038a\u0387\u0001\u0000\u0000\u0000\u038a\u0389\u0001\u0000\u0000"+
		"\u0000\u038bi\u0001\u0000\u0000\u0000\u038c\u038d\u0007\u0010\u0000\u0000"+
		"\u038d\u0390\u0003t:\u0000\u038e\u0390\u0003t:\u0000\u038f\u038c\u0001"+
		"\u0000\u0000\u0000\u038f\u038e\u0001\u0000\u0000\u0000\u0390k\u0001\u0000"+
		"\u0000\u0000\u0391\u0393\u0007\u0011\u0000\u0000\u0392\u0394\u0003t:\u0000"+
		"\u0393\u0392\u0001\u0000\u0000\u0000\u0393\u0394\u0001\u0000\u0000\u0000"+
		"\u0394\u0397\u0001\u0000\u0000\u0000\u0395\u0397\u0003t:\u0000\u0396\u0391"+
		"\u0001\u0000\u0000\u0000\u0396\u0395\u0001\u0000\u0000\u0000\u0397m\u0001"+
		"\u0000\u0000\u0000\u0398\u039a\u00059\u0000\u0000\u0399\u0398\u0001\u0000"+
		"\u0000\u0000\u039a\u039b\u0001\u0000\u0000\u0000\u039b\u0399\u0001\u0000"+
		"\u0000\u0000\u039b\u039c\u0001\u0000\u0000\u0000\u039co\u0001\u0000\u0000"+
		"\u0000\u039d\u039e\u0005\u001e\u0000\u0000\u039eq\u0001\u0000\u0000\u0000"+
		"\u039f\u03a1\u0007\u0012\u0000\u0000\u03a0\u039f\u0001\u0000\u0000\u0000"+
		"\u03a1\u03a2\u0001\u0000\u0000\u0000\u03a2\u03a0\u0001\u0000\u0000\u0000"+
		"\u03a2\u03a3\u0001\u0000\u0000\u0000\u03a3s\u0001\u0000\u0000\u0000\u03a4"+
		"\u03a6\u0003v;\u0000\u03a5\u03a4\u0001\u0000\u0000\u0000\u03a6\u03a9\u0001"+
		"\u0000\u0000\u0000\u03a7\u03a5\u0001\u0000\u0000\u0000\u03a7\u03a8\u0001"+
		"\u0000\u0000\u0000\u03a8u\u0001\u0000\u0000\u0000\u03a9\u03a7\u0001\u0000"+
		"\u0000\u0000\u03aa\u03ab\u0007\u0013\u0000\u0000\u03abw\u0001\u0000\u0000"+
		"\u0000\u03ac\u03ae\u0005)\u0000\u0000\u03ad\u03af\u00032\u0019\u0000\u03ae"+
		"\u03ad\u0001\u0000\u0000\u0000\u03ae\u03af\u0001\u0000\u0000\u0000\u03af"+
		"\u03b1\u0001\u0000\u0000\u0000\u03b0\u03b2\u0003\u0002\u0001\u0000\u03b1"+
		"\u03b0\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2"+
		"\u03b4\u0001\u0000\u0000\u0000\u03b3\u03b5\u0003:\u001d\u0000\u03b4\u03b3"+
		"\u0001\u0000\u0000\u0000\u03b4\u03b5\u0001\u0000\u0000\u0000\u03b5y\u0001"+
		"\u0000\u0000\u0000\u03b6\u03b7\u0007\u0014\u0000\u0000\u03b7{\u0001\u0000"+
		"\u0000\u0000\u03b8\u03b9\u0005\t\u0000\u0000\u03b9}\u0001\u0000\u0000"+
		"\u0000\u03ba\u03bb\u0007\u0015\u0000\u0000\u03bb\u007f\u0001\u0000\u0000"+
		"\u0000\u03bc\u03bd\u0005\u0005\u0000\u0000\u03bd\u0081\u0001\u0000\u0000"+
		"\u0000\u03be\u03bf\u0005*\u0000\u0000\u03bf\u0083\u0001\u0000\u0000\u0000"+
		"\u0081\u0085\u008e\u0096\u009e\u00a9\u00b1\u00ba\u00c2\u00d1\u00d7\u00e2"+
		"\u00e7\u00eb\u00f2\u00f5\u00fb\u0106\u010c\u0111\u0114\u011a\u011f\u0122"+
		"\u0130\u0134\u0144\u014a\u0152\u0155\u0157\u015c\u015f\u0166\u016c\u0172"+
		"\u0175\u0179\u0189\u0190\u0197\u019e\u01b2\u01c1\u01c3\u01c5\u01ca\u01cf"+
		"\u01d4\u01d9\u01e0\u01e3\u01e6\u01e9\u01f6\u01fa\u0200\u0205\u0208\u020b"+
		"\u020e\u0214\u0219\u021e\u022b\u0230\u0233\u0239\u023c\u0241\u0247\u024c"+
		"\u0252\u0257\u025d\u0264\u0267\u0273\u0277\u027b\u0280\u0284\u0287\u028d"+
		"\u0291\u0295\u029a\u029e\u02a1\u02a9\u02ae\u02b2\u02b7\u02bc\u02c0\u02c6"+
		"\u02c9\u02ce\u02d3\u02da\u02e2\u02e9\u02ef\u02f6\u02fa\u0310\u0313\u0316"+
		"\u031a\u0324\u032c\u0335\u033f\u0346\u034c\u0350\u0358\u0364\u0373\u037b"+
		"\u038a\u038f\u0393\u0396\u039b\u03a2\u03a7\u03ae\u03b1\u03b4";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}